//--------------------------------------------------------------------//
//   戦略シミュレーション ver.0.1				      //
//					  2002/04/07 作成  樋口和宏   //
//--------------------------------------------------------------------//
// クラス一覧
//  interface Parameters        パラメータインターフェイス
//  interface Words             使用単語インターフェイス
//  interface ControlPanel      コントロールパネルインターフェイス
//  interface DivisionAction    部隊行動パラメータインターフェイス
//  interface DivisionStatus    部隊状態パラメータインターフェイス
//  interface Exchange          交換ボタンインターフェイス
//  class WCP                   メイン
//  class WCPPanel              フィールド表示部分
//  class WCPDataCore           データ管理
//  class Formation             部隊編成クラス
//  class Supply                部隊補給クラス
//  class FieldParts            フィールド部品クラス
//  class Castle                城クラス
//  class Grid                  フィールドデータクラス
//  class Nation                国家クラス
//  class Division              部隊クラス
//  class Weapon                兵種クラス
//  class General               武将クラス
//  class drawDivision          部隊描画クラス
//  class StringList            文字列リストクラス
//  class ControlButton         コントロールボタンクラス
//  class ImageData             イメージクラス
//  class ClearFilter           指定した色を透明にするフィルタ
//  class halfClearFilter       半透明にするフィルタ
//--------------------------------------------------------------------//

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.lang.*;
import java.util.*;
import java.io.*;
import java.net.URL;

//--------------------------------------------------------------------//
// パラメータインターフェイス
interface Parameters{
  static final int FIELDMAX=100;        // フィールド部品種類数の上限
  static final int GRIDMAX=100000;      // フィールドデータの上限
  static final int CASTLEMAX=100;       // 城の数の上限
  static final int NATIONMAX=50;        // 国家数の上限
  static final int WEAPONMAX=50;        // 兵種数の上限
  static final int GENERALMAX=1000;     // 武将数の上限
  static final int NATIONDIV=100;       // 国家所属部隊数の上限
  static final int DIVGENERAL=10;       // 部隊所属将軍数の上限
  static final int COORDMAX=1000;       // 座標値の上限
  static final int TURNMAX=10000;       // ターン数の上限

  static final int MAXNUMBER=10000;     // 物資・兵力の上限
  static final int MAXCLASS=1000;       // 城のパラメータの上限
  static final int MAXPARAMETER=100;    // パラメータの上限
  static final int MINPARAMETER=10;     // パラメータの下限

  static final int NONE=-1;             // ボタン・パネル選択

  static final int GAME=0;              // ゲーム続行
  static final int GAMEOVER=-1;         // ゲームオーバー
  static final int GAMEWIN=1;           // ゲーム勝利

  static final int GRID=10;             // 描画範囲内のマス目の数
  static final int GHALF=5;
  static final int MARGINX=4;           // マージン
  static final int MARGINY=2;
  static final int MOVING=10;           // 移動コマ最大数
  static final int COST=100;            // 建設・募兵コスト
  static final int MOVEMAX=5;           // 必要機動力の上限
  static final int EFFECTMAX=10;        // 地形効果の上限

  static final int AMBUSHCOEF=2;        // 奇襲攻撃の係数
  static final double FRONTCOEF=1.0;    // 正面攻撃の係数
  static final double SIDECOEF=0.8;     // 側面攻撃の係数
  static final double BACKCOEF=0.5;     // 背後からの攻撃の係数

  static final double ESCAPE=0.1;       // 兵士脱走率
  static final double EAT=1.0/30.0;     // 1ターンの兵糧消費量
  static final int NEWSOLDIER=10;       // 新兵の訓練度
  static final int ROYALDIVISION=0;     // 王の所属する部隊

  static final int CURSOR=0;            // カーソル部品
  static final int SELECTEDAREA=1;      // 選択範囲部品
}

//--------------------------------------------------------------------//
// 使用単語インターフェイス
interface Words{
  static final String NEXTPAGE="次ページ";
  static final String YES="はい",NO="いいえ";
  static final String SELECTPLAYERNATION="プレイヤーの国家を選んで下さい";
  static final String TACTICS="の戦略",TURN="ターン";
  static final String GAMEOVERMESSAGE="は滅亡しました";
  static final String GAMECLEARMESSAGE="は天下を統一しました";

  static final String MOVENEED="必要機動力：";
  static final String EFFECT="地形効果：";
  static final String FOODLABEL="兵糧：";
  static final String MONEYLABEL="資金：";
  static final String FOODPRODUCT="農業生産：";
  static final String MONEYPRODUCT="商業生産：";
  static final String CASTLECLASS="城郭規模：";
  static final String KING="君主：";
  static final String SOLNUMBER="兵数：";
  static final String DIVNUMBER="部隊数：";
  static final String GENERALNUMBER="武将数：";
  static final String TRAIN="訓練度：";
  static final String WEAPON="兵種：";
  static final String MOVEP="機動力：";
  static final String POSITION="位置：";
  static final String GENERALLIST[]={"武将名  ","政略","知略","指揮"
                                    ,"武力","魅力"};
  static final String DIVSTATUS[]={"待機","移動済","行動済"};
  static final String ARMYNAME[]={"第","軍"};
  static final String AMBUSHD="伏兵";

  static final String NATIONNAME="国家名　";
  static final String DIVNAME="部隊名　";
  static final String WEAPONNAME="兵種　";
}

//--------------------------------------------------------------------//
// コントロールパネルインターフェイス
interface ControlPanel{
  static final int LOCALMAP=-1;         // 画面モード
  static final int GLOBALMAP=0;
  static final int DIVISIONLIST=1;
  static final int NATIONLIST=2;
  static final int TURNENDBUTTON=3;

  static final String CNTPANELBUTTON[]={"全体マップ","部隊一覧","国家一覧"
                                       ,"ターン終了"};
}

//--------------------------------------------------------------------//
// 部隊行動パラメータインターフェイス
interface DivisionAction{
  static final int MOVE=0;              // 状態スイッチ
  static final int ATTACK=1;
  static final int DIRECTION=2;
  static final int FORMATION=3;
  static final int TRAINING=4;
  static final int SUPPLY=5;
  static final int CONSTRUCT=6;
  static final int CONSTFOOD=7;
  static final int CONSTMONEY=8;
  static final int CONSTCASTLE=9;
  static final int OCCUPY=10;
  static final int AMBUSH=11;
  static final int INFOMATION=12;
  static final int ACTIONEND=13;
  static final int ACTIONDONE=14;

  static final int PLAYERTURN=15;
  static final int ENEMYTURN=16;
  static final int SELECT=17;
  static final int EXCHANGE=18;
  static final int NATIONSELECT=19;
  static final int TURNEND=20;

  static final String DIVBUTTON[]={"移動","攻撃","方向","編成","訓練"
                                  ,"補給","建設","農業","商業","城郭"
                                  ,"占領","伏兵","情報","終了","済"};

  static final String
    SELECTMESSAGE[]={"移動先を指定して下さい","攻撃相手を指定して下さい"
                    ,"方向を指定して下さい","編成相手を指定して下さい"};
  static final String TURNENDCONFIRM="行動を終了しますか？";
}

//--------------------------------------------------------------------//
// 部隊状態パラメータインターフェイス
interface DivisionStatus{
  static final int WAIT=0;              // 部隊の状態
  static final int MOVED=1;
  static final int DONE=2;

  static final int NORTH=0;             // 部隊の向いている方向
  static final int EAST=1;
  static final int SOUTH=2;
  static final int WEST=3;
}

//--------------------------------------------------------------------//
// 交換ボタンインターフェイス
interface Exchange{
  static final int DELTA[]={1000,100,10};   // 交換量
  static final String DELTALABEL1[]={"1000 >","100 >","10 >"};
  static final String DELTALABEL2[]={"< 1000","< 100","< 10"};
  static final int LEFTRIGHT=0;             // 交換方向
  static final int RIGHTLEFT=1;
  static final String SOLDIERSUPPLY="募兵";
  static final String DECIDE="決定",CANCEL="取消";
}

//--------------------------------------------------------------------//
// メイン
public class WCP extends Applet{
  WCPPanel wcppanel;
  private Image template=null;
  private MediaTracker mt=new MediaTracker(this);

//--------------------------------------------------------------------//
  public void init(){
// データ読み込み
    String fname,iname,fontName,size;
    int imageSize=40,fontSize=12;
    int waitTime1=200,waitTime2=10,attackAction=10;

    URL base=getDocumentBase();
    fname=getParameter("data");
    if(fname==null) fname="sumple.dat";
    iname=getParameter("image");
    if(iname==null) iname="template.gif";
    size=getParameter("imagesize");
    if(size!=null) imageSize=Integer.parseInt(size);
    fontName=getParameter("fontname");
    if(fontName==null) fontName="Monospaced";
    size=getParameter("fontsize");
    if(size!=null) fontSize=Integer.parseInt(size);
    setLayout(new BorderLayout());
    getTemplateImage(iname);
    try{
      mt.waitForAll();
      wcppanel=new WCPPanel(base,fname,template,imageSize
      	      	      	   ,fontName,fontSize,Color.black,Color.white);
      wcppanel.setRunParameter(waitTime1,waitTime2,attackAction);
      add("Center",wcppanel);
    }
    catch(InterruptedException e){
    }
  }

//--------------------------------------------------------------------//
  public void destroy(){
    remove(wcppanel);
  }

//--------------------------------------------------------------------//
  void getTemplateImage(String iname){
// テンプレートイメージ読み込み
    URL ibase=getClass().getResource(iname);
    template=getToolkit().getImage(ibase);
    mt.addImage(template,0);
  }
}

//--------------------------------------------------------------------//
// フィールド表示部分
class WCPPanel extends Panel
  implements Runnable,MouseListener,MouseMotionListener,KeyListener
            ,Parameters,Words,ControlPanel,DivisionAction,DivisionStatus
            ,Exchange{

  WCPDataCore dc;
  private Thread viewThread=null;
  private String errorMessage;      // エラーメッセージ
  int fx,fy;                        // 地図表示サイズ・位置
  int sy;                           // 文字表示高さ
  private Image bgImage;            // ダブルバッファリング用イメージ
  private Graphics bg;
  int mapPoint=NONE;                // 地図上の位置
  int indexViewRange;               // 1ページ当りのリスト行数
  int divisionPage=0,nationPage=0;  // リストページ数
  int currentPage=1;                // 現在のリストページ
  int currentIndex=0;               // 現在のリスト位置
  int mousex=0,mousey=0;            // マウス位置
  int mapmode=LOCALMAP;             // 画面モード
  int status=NATIONSELECT;          // 状態スイッチ
  int waitTime1=200;                // 移動時表示待ち時間
  int waitTime2=10;                 // 攻撃時表示待ち時間
  int attackAction=10;              // 攻撃行動グラフィック表示回数
  Color backColor,textColor;        // 背景色・文字色
  int turn=0;                       // ターン数
  String GameOverMessage,GameClearMessage;
  private Font font;                // 文字フォント
  private FontMetrics fm;
  private boolean running=false;
  ControlButton divCntButton[]=new ControlButton[DIVBUTTON.length]; // ボタン
  ControlButton cntPnlButton[]=new ControlButton[CNTPANELBUTTON.length];
  ControlButton exchangeButton[]=new ControlButton[6*DELTA.length];
  ControlButton yes,no,soldierSupply,decide,cancel,nextPage;

  WCPPanel(URL base,String name,Image image,int imageSize
      	  ,String fontName,int fontSize,Color backColor,Color textColor){
    font=new Font(fontName,Font.PLAIN,fontSize);
    this.backColor=backColor;
    this.textColor=textColor;
    getData(base,name,image,imageSize);
    setBackground(backColor);
    addMouseListener(this);
    addMouseMotionListener(this);
    addKeyListener(this);
    dc.setViewPoint(0);
  }

//--------------------------------------------------------------------//
  void getData(URL base,String name,Image image,int imageSize){
// データ読み込み
    InputStream is=null;

    errorMessage=null;
    try{
      is=new URL(base,name).openStream();
      dc=new WCPDataCore(is,image,imageSize,backColor,textColor);
    }
    catch(Exception e){
      errorMessage=e.toString();
    }
    try{
      if(is!=null) is.close();
    }
    catch(Exception e){
    }
  }

//--------------------------------------------------------------------//
  void setRunParameter(int waitTime1,int waitTime2,int attackAction){
// アニメーションパラメータの設定
    this.waitTime1=waitTime1;
    this.waitTime2=waitTime2;
    this.attackAction=attackAction;
  }

//--------------------------------------------------------------------//
  void start(){
    if(viewThread==null){
      viewThread=new Thread(this);
      viewThread.start();
    }
  }

//--------------------------------------------------------------------//
  public void run(){
    if(running) return;
    running=true;
    switch(status){
      default:
      	break;
      case MOVE:
      	moveRun();
      	status=PLAYERTURN;
      	break;
      case ATTACK:
      	attackRun();
      	status=PLAYERTURN;
      	break;
      case TRAINING:
      	trainingRun();
      	status=PLAYERTURN;
      	break;
      case ENEMYTURN:
      	enemyTurnRun();
      	status=PLAYERTURN;
      	break;
    }
    stop();
    running=false;
  }

//--------------------------------------------------------------------//
  void moveRun(){
// 移動行動
    int i;

    if(dc.currentDivision!=NONE){
      for(i=dc.moving-1;i>=0;i--){
      	dc.moveDraw(i);
      	repaint();
      	try{
      	  viewThread.sleep(waitTime1);
      	}
      	catch(InterruptedException e){
      	}
      }
      dc.setDivViewPoint(dc.currentNation,dc.currentDivision);
      dc.moveDone();
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void attackRun(){
// 攻撃行動
    int i;

    if(dc.currentDivision!=NONE){
      for(i=0;i<attackAction;i++){
      	dc.attackDraw(i%2);
      	repaint();
      	try{
      	  viewThread.sleep(waitTime2);
      	}
      	catch(InterruptedException e){
      	}
      }
      dc.attackCalculate();
      dc.actionDone();
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void trainingRun(){
// 訓練行動
    int i;

    if(dc.currentDivision!=NONE && dc.Training()){
      for(i=0;i<attackAction;i++){
      	dc.attackDraw(i%2);
      	repaint();
      	try{
      	  viewThread.sleep(waitTime2);
      	}
      	catch(InterruptedException e){
      	}
      }
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void enemyTurnRun(){
// CPUの行動
    int div,ndiv;
    boolean EnemyTurn,EndOfDivision;

    EnemyTurn=(dc.currentNation!=dc.playerNation);
    while(EnemyTurn){
      div=0;
      ndiv=dc.nation[dc.currentNation].divisionNumber;
      EndOfDivision=(ndiv==0);
      while(!EndOfDivision){
      	dc.findAttackDivision(dc.currentNation,div);
      	mapPoint=dc.moveTarget;                                 // 移動
      	dc.setMoveDivision(mapPoint);
      	dc.clearMoveDistance();
      	moveRun();
      	try{
      	  viewThread.sleep(waitTime1);
      	}
      	catch(InterruptedException e){
      	}
      	if(dc.attackedDivision!=NONE){                          // 攻撃
      	  mapPoint=dc.divisionPoint(dc.attackedNation
      	      	      	      	   ,dc.attackedDivision);
      	  dc.setAttackDivision(mapPoint,dc.attackedNation
      	      	      	      ,dc.attackedDivision);
      	  dc.clearAttackDistance();
      	  attackRun();
      	  try{
      	    viewThread.sleep(waitTime1);
      	  }
      	  catch(InterruptedException e){
      	  }
      	}
      	if(dc.game!=GAME){                             // ゲームオーバー
      	  EnemyTurn=false;
      	  EndOfDivision=true;
      	}
      	if(dc.currentDivision==NONE){
      	  div=0;
      	}
      	else{
      	  if(dc.nation[dc.currentNation].divisionNumber==ndiv){
      	    div++;
      	  }
      	  else{
      	    ndiv=dc.nation[dc.currentNation].divisionNumber;
      	  }
      	  if(div>=dc.nation[dc.currentNation].divisionNumber) EndOfDivision=true;
      	}
      }
      dc.nextNation();
      if(dc.currentNation==0) nextTurn();
      if(dc.currentNation==dc.playerNation) EnemyTurn=false;
    }
    if(dc.game==GAME){
      dc.setCurrentDivision(dc.playerNation,NONE);
      dc.setDivViewPoint(dc.playerNation,0);
    }
    repaint();
  }

//--------------------------------------------------------------------//
  void stop(){
    viewThread=null;
  }

//--------------------------------------------------------------------//
  public void mouseClicked(MouseEvent e){
  }

//--------------------------------------------------------------------//
  public void mousePressed(MouseEvent e){
    int newpt;

    if(running) return;
    mousex=e.getX();
    mousey=e.getY();
    if(status==NATIONSELECT){
      actionNationSelect();
    }
    else if(status==EXCHANGE){
      actionDivisionExchange();
    }
    else if(status==SUPPLY){
      actionSupply();
    }
    else if(status==CONSTRUCT){
      actionConstruct();
    }
    else if(status==INFOMATION){
      actionInfomation();
    }
    else if(status==TURNEND){
      actionTurnEnd();
    }
    else{
      switch(mapmode){
      	case LOCALMAP:
      	  newpt=dc.getMapPointLocal(mousex,mousey);
      	  if(newpt!=NONE){
      	    mapPoint=newpt;
      	    switch(status){
      	      case PLAYERTURN:
      	      	actionPlayerTurn();
      	      	break;
      	      case MOVE:
      	      	actionMove();
      	      	break;
      	      case ATTACK:
      	      	actionAttack();
      	      	break;
      	      case DIRECTION:
      	      	actionDirection();
      	      	break;
      	      case FORMATION:
      	      	actionFormation();
      	      	break;
      	    }
      	  }
      	  else{
      	    if(cntPnlButton[GLOBALMAP].press(mousex,mousey)){
      	      mapmode=GLOBALMAP;
      	      cntPnlButton[GLOBALMAP].Release();
      	    }
      	    else if(cntPnlButton[DIVISIONLIST].press(mousex,mousey)){
      	      mapmode=DIVISIONLIST;
      	      divisionPage=(dc.nation[dc.playerNation].divisionNumber-1)
      	      	      	   /indexViewRange+1;
      	      currentPage=1;
      	      cntPnlButton[DIVISIONLIST].Release();
      	    }
      	    else if(cntPnlButton[NATIONLIST].press(mousex,mousey)){
      	      mapmode=NATIONLIST;
      	      nationPage=(dc.nationNumber-1)/indexViewRange+1;
      	      currentPage=1;
      	      cntPnlButton[NATIONLIST].Release();
      	    }
      	    else if(cntPnlButton[TURNENDBUTTON].press(mousex,mousey)){
      	      status=TURNEND;
      	      cntPnlButton[TURNENDBUTTON].Release();
      	    }
      	  }
      	  break;
      	case GLOBALMAP:
      	  actionGlobalMap();
      	  break;
      	case DIVISIONLIST:
      	  actionDivisionList();
      	  break;
      	case NATIONLIST:
      	  actionNationList();
      	  break;
      }
    }
    repaint();
    e.consume();
  }

//--------------------------------------------------------------------//
  void actionNationSelect(){
// 国家選択画面での行動
    int ofset=(currentPage-1)*indexViewRange;
    if(nextPage.press(mousex,mousey)){
      currentPage=currentPage%nationPage+1;
      nextPage.Release();
    }
    else if(currentIndex<Math.min(dc.nationNumber-ofset,indexViewRange)){
      dc.setPlayerNation(ofset+currentIndex);
      GameOverMessage=dc.nation[dc.playerNation].name+GAMEOVERMESSAGE;
      GameClearMessage=dc.nation[dc.playerNation].name+GAMECLEARMESSAGE;
      dc.allWait();
      turn++;
      status=ENEMYTURN;
      mapmode=LOCALMAP;
      start();
    }
  }

//--------------------------------------------------------------------//
  void actionDivisionExchange(){
// 部隊編成画面での行動
    int i;

    if(decide.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.formationSet(mapPoint);
    }
    else if(cancel.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.formationCancel();
    }
    else{
      for(i=0;i<DELTA.length;i++){
      	if(exchangeButton[i].press(mousex,mousey)){
      	  dc.foodExchange(LEFTRIGHT,DELTA[i]);                  // 兵糧編成
      	  exchangeButton[i].Release();
      	}
      	else if(exchangeButton[i+DELTA.length].press(mousex,mousey)){
      	  dc.foodExchange(RIGHTLEFT,DELTA[i]);
      	  exchangeButton[i+DELTA.length].Release();
      	}
      	else if(exchangeButton[i+2*DELTA.length].press(mousex,mousey)){
      	  dc.moneyExchange(LEFTRIGHT,DELTA[i]);                 // 所持金編成
      	  exchangeButton[i+2*DELTA.length].Release();
      	}
      	else if(exchangeButton[i+3*DELTA.length].press(mousex,mousey)){
      	  dc.moneyExchange(RIGHTLEFT,DELTA[i]);
      	  exchangeButton[i+3*DELTA.length].Release();
      	}
      	else if(exchangeButton[i+4*DELTA.length].press(mousex,mousey)){
      	  dc.soldierExchange(LEFTRIGHT,DELTA[i]);               // 兵数編成
      	  exchangeButton[i+4*DELTA.length].Release();
      	}
      	else if(exchangeButton[i+5*DELTA.length].press(mousex,mousey)){
      	  dc.soldierExchange(RIGHTLEFT,DELTA[i]);
      	  exchangeButton[i+5*DELTA.length].Release();
      	}
      }
      if(mousex<fx/2){    // 武将編成
      	if(0<=currentIndex && currentIndex<dc.formation.generalNumber1()){
      	  dc.generalExchange(LEFTRIGHT,currentIndex);
      	}
      }
      else{
      	if(0<=currentIndex && currentIndex<dc.formation.generalNumber2()){
      	  dc.generalExchange(RIGHTLEFT,currentIndex);
      	}
      }
    }
  }

//--------------------------------------------------------------------//
  void actionSupply(){
// 部隊補給画面での行動
    int i;

    if(decide.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.supplySet(mapPoint);
    }
    else if(cancel.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.supplyCancel();
    }
    else if(soldierSupply.press(mousex,mousey)){        // 募兵
      status=PLAYERTURN;
      dc.soldierSupply(mapPoint);
      soldierSupply.Release();
    }
    else{
      for(i=0;i<DELTA.length;i++){
      	if(exchangeButton[i].press(mousex,mousey)){
      	  dc.foodSupply(LEFTRIGHT,DELTA[i]);            // 兵糧編成
      	  exchangeButton[i].Release();
      	}
      	else if(exchangeButton[i+DELTA.length].press(mousex,mousey)){
      	  dc.foodSupply(RIGHTLEFT,DELTA[i]);
      	  exchangeButton[i+DELTA.length].Release();
      	}
      	else if(exchangeButton[i+2*DELTA.length].press(mousex,mousey)){
      	  dc.moneySupply(LEFTRIGHT,DELTA[i]);           // 所持金編成
      	  exchangeButton[i+2*DELTA.length].Release();
      	}
      	else if(exchangeButton[i+3*DELTA.length].press(mousex,mousey)){
      	  dc.moneySupply(RIGHTLEFT,DELTA[i]);
      	  exchangeButton[i+3*DELTA.length].Release();
      	}
      }
    }
  }

//--------------------------------------------------------------------//
  void actionConstruct(){
// 建設画面での行動
    if(divCntButton[CONSTFOOD].press(mousex,mousey)){
      dc.constructFoodProduct(mapPoint);
    }
    else if(divCntButton[CONSTMONEY].press(mousex,mousey)){
      dc.constructMoneyProduct(mapPoint);
    }
    else if(divCntButton[CONSTCASTLE].press(mousex,mousey)){
      dc.constructCastleClass(mapPoint);
    }
    status=PLAYERTURN;
  }

//--------------------------------------------------------------------//
  void actionInfomation(){
// 部隊情報画面での行動
    status=PLAYERTURN;
  }

//--------------------------------------------------------------------//
  void actionTurnEnd(){
// ターン終了確認画面での行動
    if(yes.press(mousex,mousey)){
      playerTurnEnd();
      yes.Release();
    }
    else if(no.press(mousex,mousey)){
      status=PLAYERTURN;
      no.Release();
    }
  }

//--------------------------------------------------------------------//
  void actionPlayerTurn(){
// 通常状態での行動
    dc.setViewPoint(mapPoint);
    if(dc.setMoveDistance(mapPoint)==dc.currentNation){
      dc.setAttackDistance(mapPoint);
      dc.setFormationPlace(mapPoint);
      status=SELECT;
      setDivisionControlPanel(fm);
    }
    else if(dc.setMoveDistance(mapPoint)!=NONE){
      status=SELECT;
      setDivisionControlPanel(fm);
    }
  }

//--------------------------------------------------------------------//
  void actionMove(){
// 移動状態での行動
    dc.setMoveDivision(mapPoint);
    dc.clearMoveDistance();
    start();
  }

//--------------------------------------------------------------------//
  void actionAttack(){
// 攻撃状態での行動
    dc.setAttackDivision(mapPoint);
    dc.clearAttackDistance();
    start();
  }

//--------------------------------------------------------------------//
  void actionDirection(){
// 部隊方向の設定
    dc.setDirection(mapPoint);
    status=PLAYERTURN;
    repaint();
  }

//--------------------------------------------------------------------//
  void actionFormation(){
// 編成部隊選択状態での行動
    dc.setFormationDivision(mapPoint);
    dc.clearFormation();
    if(dc.currentDivision==NONE){
      status=PLAYERTURN;
    }
    else{
      status=EXCHANGE;
      dc.setExchangeDivision(mapPoint);
      setExchangePanel(fm);
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void actionGlobalMap(){
// 全体マップでの行動
    int newpt=dc.getMapPointGlobal(mousex,mousey);
    if(newpt!=NONE){
      mapPoint=newpt;
      dc.setViewPoint(mapPoint);
      mapmode=LOCALMAP;
    }
  }

//--------------------------------------------------------------------//
  void actionDivisionList(){
// 部隊リストでの行動
    int ofset=(currentPage-1)*indexViewRange;
    int maxIndex=Math.min(dc.nation[dc.currentNation].divisionNumber-ofset
                         ,indexViewRange);
    if(nextPage.press(mousex,mousey)){
      currentPage=currentPage%nationPage+1;
      nextPage.Release();
    }
    else if(currentIndex<maxIndex){
      dc.setDivViewPoint(dc.currentNation,ofset+currentIndex);
      mapmode=LOCALMAP;
    }
  }

//--------------------------------------------------------------------//
  void actionNationList(){
// 国家リストでの行動
    int ofset=(currentPage-1)*indexViewRange;
    if(nextPage.press(mousex,mousey)){
      currentPage=currentPage%nationPage+1;
      nextPage.Release();
    }
    else if(currentIndex<Math.min(dc.nationNumber-ofset,indexViewRange)){
      dc.setDivViewPoint(ofset+currentIndex,ROYALDIVISION);
      mapmode=LOCALMAP;
    }
  }

//--------------------------------------------------------------------//
  public void mouseReleased(MouseEvent e){
    if(running) return;
    if(status==SELECT){
      int nati=dc.grid[mapPoint].nation,div=dc.grid[mapPoint].division;
      mousex=e.getX();
      mousey=e.getY();
      if(nati==dc.playerNation){
      	switch(dc.nation[nati].division[div].status){
      	  case WAIT:
      	    mouseReleasedWait();
      	    break;
      	  case MOVED:
      	    mouseReleasedMoved();
      	    break;
      	  case DONE:
      	    mouseReleasedDone();
      	    break;
      	}
      }
      else{
      	mouseReleasedEnemy();
      }
      repaint();
      e.consume();
    }
  }

//--------------------------------------------------------------------//
  void mouseReleasedWait(){
// 待機状態でのマウスリリースの反応
    if(divCntButton[MOVE].press(mousex,mousey)){
      status=MOVE;
    }
    else{
      mouseReleasedMoved();
    }
  }

//--------------------------------------------------------------------//
  void mouseReleasedMoved(){
// 移動終了状態でのマウスリリースの反応
    if(divCntButton[ATTACK].press(mousex,mousey)){
      status=ATTACK;
    }
    else if(divCntButton[DIRECTION].press(mousex,mousey)){
      status=DIRECTION;
    }
    else if(divCntButton[FORMATION].press(mousex,mousey)){
      status=FORMATION;
    }
    else if(divCntButton[TRAINING].press(mousex,mousey)){
      status=TRAINING;
      start();
    }
    else if(divCntButton[INFOMATION].press(mousex,mousey)){
      status=INFOMATION;
    }
    else if(divCntButton[ACTIONEND].press(mousex,mousey)){
      status=PLAYERTURN;
      dc.actionDone();
    }
    else if(dc.gridNation(mapPoint)==dc.playerNation){
      if(divCntButton[SUPPLY].press(mousex,mousey)){
      	status=SUPPLY;
      	dc.setSupply(mapPoint);
      	setExchangePanel(fm);
      }
      else if(divCntButton[CONSTRUCT].press(mousex,mousey)){
      	status=CONSTRUCT;
      }
      else{
      	status=PLAYERTURN;
      }
    }
    else if(dc.canHide(mapPoint)){
      status=PLAYERTURN;
      if(divCntButton[AMBUSH].press(mousex,mousey)){
      	dc.ambushDivision();
      	dc.actionDone();
      }
    }
    else if(!dc.grid[mapPoint].castle){
      status=PLAYERTURN;
    }
    else if(divCntButton[OCCUPY].press(mousex,mousey)){
      dc.occupyCastle(mapPoint);
      status=PLAYERTURN;
    }
    else{
      status=PLAYERTURN;
    }
  }

//--------------------------------------------------------------------//
  void mouseReleasedDone(){
// 行動終了状態でのマウスリリースの反応
    if(divCntButton[INFOMATION].press(mousex,mousey)){
      status=INFOMATION;
    }
    else{
      status=PLAYERTURN;
    }
  }

//--------------------------------------------------------------------//
  void mouseReleasedEnemy(){
// 敵部隊のマウスリリースの反応
    if(divCntButton[INFOMATION].press(mousex,mousey)){
      status=INFOMATION;
    }
    else{
      status=PLAYERTURN;
    }
  }

//--------------------------------------------------------------------//
  public void mouseEntered(MouseEvent e){
  }

//--------------------------------------------------------------------//
  public void mouseExited(MouseEvent e){
  }

//--------------------------------------------------------------------//
  public void mouseDragged(MouseEvent e){
    if(running) return;
    if(status==SELECT){
      int nati=dc.grid[mapPoint].nation,div=dc.grid[mapPoint].division;
      mousex=e.getX();
      mousey=e.getY();
      if(nati==dc.playerNation){
      	switch(dc.nation[nati].division[div].status){
      	  case WAIT:
      	    mouseDraggedWait();
      	    break;
      	  case MOVED:
      	    mouseDraggedMoved();
      	    break;
      	  case DONE:
      	    mouseDraggedDone();
      	    break;
      	}
      }
      else{
      	mouseDraggedEnemy();
      }
      repaint();
      e.consume();
    }
  }

//--------------------------------------------------------------------//
  void mouseDraggedWait(){
// 待機状態でのマウスドラッグの反応
    divCntButton[MOVE].Release();
    divCntButton[MOVE].press(mousex,mousey);
    mouseDraggedMoved();
  }

//--------------------------------------------------------------------//
  void mouseDraggedMoved(){
// 移動終了状態でのマウスドラッグの反応
    divCntButton[ATTACK].Release();
    divCntButton[DIRECTION].Release();
    divCntButton[FORMATION].Release();
    divCntButton[TRAINING].Release();
    divCntButton[INFOMATION].Release();
    divCntButton[ACTIONEND].Release();
    divCntButton[ATTACK].press(mousex,mousey);
    divCntButton[DIRECTION].press(mousex,mousey);
    divCntButton[FORMATION].press(mousex,mousey);
    divCntButton[TRAINING].press(mousex,mousey);
    divCntButton[INFOMATION].press(mousex,mousey);
    divCntButton[ACTIONEND].press(mousex,mousey);
    if(dc.gridNation(mapPoint)==dc.playerNation){
      divCntButton[SUPPLY].Release();
      divCntButton[CONSTRUCT].Release();
      if(divCntButton[SUPPLY].press(mousex,mousey));
      else if(divCntButton[CONSTRUCT].press(mousex,mousey));
    }
    else if(dc.grid[mapPoint].castle){
      divCntButton[OCCUPY].Release();
      if(divCntButton[OCCUPY].press(mousex,mousey));
    }
    else if(dc.canHide(mapPoint)){
      divCntButton[AMBUSH].Release();
      if(divCntButton[AMBUSH].press(mousex,mousey));
    }
  }

//--------------------------------------------------------------------//
  void mouseDraggedDone(){
// 行動終了状態でのマウスドラッグの反応
    divCntButton[INFOMATION].Release();
    divCntButton[INFOMATION].press(mousex,mousey);
  }

//--------------------------------------------------------------------//
  void mouseDraggedEnemy(){
// 敵部隊のマウスドラッグの反応
    divCntButton[INFOMATION].Release();
    divCntButton[INFOMATION].press(mousex,mousey);
  }

//--------------------------------------------------------------------//
  public void mouseMoved(MouseEvent e){
    if(running) return;
    mousex=e.getX();
    mousey=e.getY();
    switch(status){
      default:
      	switch(mapmode){
      	  case LOCALMAP:
      	    mapPoint=dc.getMapPointLocal(mousex,mousey);
      	    break;
      	  case GLOBALMAP:
      	    mapPoint=dc.getMapPointGlobal(mousex,mousey);
      	    break;
      	  case DIVISIONLIST:
      	    currentIndex=mousey/sy;
      	    break;
      	  case NATIONLIST:
      	    currentIndex=mousey/sy;
      	    break;
      	}
      	break;
      case NATIONSELECT:
      	currentIndex=mousey/sy;
      	break;
      case SELECT:
      	break;
      case EXCHANGE:
      	currentIndex=mousey/sy-7;
      	break;
      case SUPPLY:
      	break;
      case CONSTRUCT:
      	mouseMovedConstruct();
      	break;
      case INFOMATION:
      	break;
      case TURNEND:
      	break;
    }
    repaint();
    e.consume();
  }

//--------------------------------------------------------------------//
  void mouseMovedConstruct(){
// 建設状態でのマウス移動の反応
    divCntButton[CONSTFOOD].Release();
    divCntButton[CONSTMONEY].Release();
    divCntButton[CONSTCASTLE].Release();
    divCntButton[CONSTFOOD].press(mousex,mousey);
    divCntButton[CONSTMONEY].press(mousex,mousey);
    divCntButton[CONSTCASTLE].press(mousex,mousey);
  }

//--------------------------------------------------------------------//
  public void keyPressed(KeyEvent e){
    int keyin;

    if(running) return;
    if(status!=PLAYERTURN) return;
    keyin=e.getKeyCode();
    switch(keyin){
      case KeyEvent.VK_2:
      	break;
      case KeyEvent.VK_4:
      	break;
      case KeyEvent.VK_6:
      	break;
      case KeyEvent.VK_8:
      	break;
      case KeyEvent.VK_G:
      	mapmode=GLOBALMAP;
      	repaint();
      	break;
      case KeyEvent.VK_D:
      	mapmode=DIVISIONLIST;
      	divisionPage=(dc.nation[dc.playerNation].divisionNumber-1)
      	      	     /indexViewRange+1;
      	currentPage=1;
      	repaint();
      	break;
      case KeyEvent.VK_N:
      	mapmode=NATIONLIST;
      	nationPage=(dc.nationNumber-1)/indexViewRange+1;
      	currentPage=1;
      	repaint();
      	break;
      case KeyEvent.VK_E:
      	status=TURNEND;
      	repaint();
      	break;
      case KeyEvent.VK_Q:
      	mapmode=LOCALMAP;
      	repaint();
      	break;
    }
  }

//--------------------------------------------------------------------//
  public void keyReleased(KeyEvent e){
  }

//--------------------------------------------------------------------//
  public void keyTyped(KeyEvent e){
  }

//--------------------------------------------------------------------//
  void playerTurnEnd(){
// プレイヤーターン終了
    status=ENEMYTURN;
    dc.nextNation();
    if(dc.currentNation==0) nextTurn();
    start();
  }

//--------------------------------------------------------------------//
  void nextTurn(){
// 次のターンへ
    dc.nextTurn();
    turn++;
  }

//--------------------------------------------------------------------//
  void setDivisionControlPanel(FontMetrics fm){
// 部隊コントロールパネル設定
    int i,nati,div,x0,y0,cx,iend=5;
    int cy[]=new int[10];

    if(mousex>=dc.viewSize || mousey>=dc.viewSize) return;
    nati=dc.grid[mapPoint].nation;
    div=dc.grid[mapPoint].division;
    x0=dc.gridSize*(dc.nation[nati].pointX(div)-dc.viewx+GHALF);
    y0=dc.gridSize*(dc.nation[nati].pointY(div)-dc.viewy+GHALF);
    if(x0<(int)(0.6*dc.viewSize)){
      cx=x0+dc.gridSize+MARGINX;
    }
    else{
      cx=x0-fm.stringWidth(DIVBUTTON[0])-2*MARGINX;
    }

    if(nati==dc.playerNation){
      if(y0<(int)(0.6*dc.viewSize)){
      	cy[0]=y0+2;
      	for(i=1;i<cy.length;i++){
      	  cy[i]=cy[i-1]+sy;
      	}
      }
      else{
      	cy[cy.length-1]=y0+dc.gridSize-sy-2;
      	for(i=cy.length-1;i>0;i--){
      	  cy[i-1]=cy[i]-sy;
      	}
      }
      divCntButton[MOVE]=new ControlButton(fm,DIVBUTTON[MOVE],cx,cy[0]);
      divCntButton[ATTACK]=
      	new ControlButton(fm,DIVBUTTON[ATTACK],cx,cy[1]);
      divCntButton[DIRECTION]=
      	new ControlButton(fm,DIVBUTTON[DIRECTION],cx,cy[2]);
      divCntButton[FORMATION]=
      	new ControlButton(fm,DIVBUTTON[FORMATION],cx,cy[3]);
      divCntButton[TRAINING]=
      	new ControlButton(fm,DIVBUTTON[TRAINING],cx,cy[4]);
      if(dc.gridNation(mapPoint)==dc.playerNation){
      	divCntButton[SUPPLY]=
      	  new ControlButton(fm,DIVBUTTON[SUPPLY],cx,cy[5]);
      	divCntButton[CONSTRUCT]=
      	  new ControlButton(fm,DIVBUTTON[CONSTRUCT],cx,cy[6]);
      	divCntButton[CONSTFOOD]=
      	  new ControlButton(fm,DIVBUTTON[CONSTFOOD],cx,cy[0]);
      	divCntButton[CONSTMONEY]=
      	  new ControlButton(fm,DIVBUTTON[CONSTMONEY],cx,cy[1]);
      	divCntButton[CONSTCASTLE]=
      	  new ControlButton(fm,DIVBUTTON[CONSTCASTLE],cx,cy[2]);
      	iend+=2;
      }
      else if(dc.grid[mapPoint].castle){
      	divCntButton[OCCUPY]=
      	  new ControlButton(fm,DIVBUTTON[OCCUPY],cx,cy[5]);
      	iend++;
      }
      else if(dc.canHide(mapPoint)){
      	divCntButton[AMBUSH]=
      	  new ControlButton(fm,DIVBUTTON[AMBUSH],cx,cy[5]);
      	iend++;
      }
      divCntButton[INFOMATION]=
      	new ControlButton(fm,DIVBUTTON[INFOMATION],cx,cy[iend]);
      divCntButton[ACTIONEND]=
      	new ControlButton(fm,DIVBUTTON[ACTIONEND],cx,cy[iend+1]);
      divCntButton[ACTIONDONE]=
      	new ControlButton(fm,DIVBUTTON[ACTIONDONE],cx,cy[iend+1]);
    }
    else{
      divCntButton[INFOMATION]=
      	new ControlButton(fm,DIVBUTTON[INFOMATION],cx,y0);
    }
  }

//--------------------------------------------------------------------//
  void setControlPanel(FontMetrics fm){
// コントロールパネル設定
    int x1,x2,x0,y0;

    x0=dc.viewSize+MARGINX;
    y0=fy-2*sy-MARGINY;
    x1=x0+fm.stringWidth(CNTPANELBUTTON[0])+MARGINX;
    x2=x1+fm.stringWidth(CNTPANELBUTTON[1])+MARGINX;
    cntPnlButton[GLOBALMAP]=
      new ControlButton(fm,CNTPANELBUTTON[GLOBALMAP],x0,y0);
    cntPnlButton[DIVISIONLIST]=
      new ControlButton(fm,CNTPANELBUTTON[DIVISIONLIST],x1,y0);
    cntPnlButton[NATIONLIST]=
      new ControlButton(fm,CNTPANELBUTTON[NATIONLIST],x2,y0);
    cntPnlButton[TURNENDBUTTON]=
      new ControlButton(fm,CNTPANELBUTTON[TURNENDBUTTON],x0,y0+sy);

    x1=Math.max(fm.stringWidth(YES),fm.stringWidth(NO))+MARGINX;
    x0=fx/4-x1/2;
    y0=(fy-sy)/2;
    yes=new ControlButton(fm,YES,x0,y0,x1,sy);
    no=new ControlButton(fm,NO,x0+fx/2,y0,x1,sy);

    x0=2*MARGINX+fm.stringWidth(SELECTPLAYERNATION);
    y0=fy-sy-MARGINY;
    nextPage=new ControlButton(fm,NEXTPAGE,x0,y0);
  }

//--------------------------------------------------------------------//
  void setExchangePanel(FontMetrics fm){
// 交換ボタンパネル設定
    int i,i2,j,j1,j2,sx,x0,y0;
    int ex[]=new int[2*DELTA.length];
    int ex0[]=new int[2*DELTA.length];

    x0=fx/2;
    y0=MARGINY+4*sy;
    soldierSupply=new ControlButton(fm,SOLDIERSUPPLY,x0,y0);

    sx=fm.stringWidth(DECIDE)+MARGINX;
    x0=fx/4-sx/2;
    y0=fy-sy-MARGINY;
    decide=new ControlButton(fm,DECIDE,x0,y0);
    cancel=new ControlButton(fm,CANCEL,x0+fx/2,y0);

    for(i=0;i<DELTA.length;i++){
      ex[i]=fm.stringWidth(DELTALABEL1[i])+MARGINX;
      ex[i+DELTA.length]=fm.stringWidth(DELTALABEL2[i])+MARGINX;
    }
    ex0[DELTA.length-1]=fx/2-ex[DELTA.length-1]-MARGINX;
    ex0[2*DELTA.length-1]=fx-ex[2*DELTA.length-1]-MARGINX;
    for(i=DELTA.length-2;i>=0;i--){
      i2=i+DELTA.length;
      ex0[i]=ex0[i+1]-ex[i]-MARGINX;
      ex0[i2]=ex0[i2+1]-ex[i2]-MARGINX;
    }
    for(i=0;i<DELTA.length;i++){
      y0=MARGINY/2+2*sy;
      i2=i+DELTA.length;
      j1=i;
      j2=i2;
      for(j=0;j<3;j++){
      	exchangeButton[j1]=new ControlButton(fm,DELTALABEL1[i],ex0[i],y0);
      	exchangeButton[j2]=new ControlButton(fm,DELTALABEL2[i],ex0[i2],y0);
      	y0+=sy;
      	j1+=2*DELTA.length;
      	j2+=2*DELTA.length;
      }
    }
  }

//--------------------------------------------------------------------//
  public void update(Graphics g){
    if(dc!=null){
      drawScreen(bg);
      g.drawImage(bgImage,0,0,this);
    }
    else if(errorMessage!=null){
      drawError(g,errorMessage);
    }
  }

//--------------------------------------------------------------------//
  public void paint(Graphics g){
    setScreen(g);
    if(dc!=null){
      dc.setGridSize(Math.min(fx,fy));
      setControlPanel(fm);
      drawScreen(bg);
      g.drawImage(bgImage,0,0,this);
    }
    else if(errorMessage!=null){
      drawError(g,errorMessage);
    }
  }

//--------------------------------------------------------------------//
  void setScreen(Graphics g){
// 画面設定
    g.setFont(font);
    fx=getSize().width;
    fy=getSize().height;
    bgImage=createImage(fx,fy);
    bg=bgImage.getGraphics();
    bg.setFont(font);
    fm=bg.getFontMetrics();
    sy=fm.getHeight()+MARGINY;
    indexViewRange=fy/sy-1;
    nationPage=(dc.nationNumber-1)/indexViewRange+1;
  }

//--------------------------------------------------------------------//
  void drawScreen(Graphics g){
// 画面描画
    switch(dc.game){
      case GAME:
      	g.setColor(backColor);
      	g.fillRect(0,0,fx,fy);
      	switch(mapmode){
      	  case LOCALMAP:
      	    drawLocalMap(g);
      	    break;
      	  case GLOBALMAP:
      	    drawGlobalMap(g);
      	    break;
      	  case DIVISIONLIST:
      	    drawDivisionList(g);
      	    break;
      	  case NATIONLIST:
      	    drawNationList(g);
      	    break;
      	}
      	break;
      case GAMEOVER:
      	drawError(g,GameOverMessage);
      	break;
      case GAMEWIN:
      	drawError(g,GameClearMessage);
      	break;
    }
  }

//--------------------------------------------------------------------//
  void drawLocalMap(Graphics g){
// マップ描画
    switch(status){
      default:
      	drawLocalMapBase(g);
      	drawTurn(g);
      	drawCursorLocal(g);
      	break;
      case NATIONSELECT:
      	drawNationList(g);
      	g.setColor(textColor);
      	g.drawString(SELECTPLAYERNATION,MARGINX,fy-MARGINY);
      	break;
      case SELECT:
      	drawLocalMapBase(g);
      	drawTurn(g);
      	drawDivisionControlPanel(g);
      	break;
      case MOVE:
      	drawLocalMapBase(g);
      	drawInfo(g,SELECTMESSAGE[MOVE]);
      	dc.drawMoveDistance(g);
      	drawCursorLocal(g);
      	break;
      case ATTACK:
      	drawLocalMapBase(g);
      	drawInfo(g,SELECTMESSAGE[ATTACK]);
      	dc.drawAttackDistance(g);
      	drawCursorLocal(g);
      	break;
      case DIRECTION:
      	drawLocalMapBase(g);
      	drawInfo(g,SELECTMESSAGE[DIRECTION]);
      	drawCursorLocal(g);
      	break;
      case FORMATION:
      	drawLocalMapBase(g);
      	drawInfo(g,SELECTMESSAGE[FORMATION]);
      	dc.drawFormationPlace(g);
      	drawCursorLocal(g);
      	break;
      case EXCHANGE:
      	drawDivisionExchange(g,MARGINX,sy,fx/2,sy);
      	break;
      case SUPPLY:
      	drawSupply(g,MARGINX,sy,fx/2,sy);
      	break;
      case CONSTRUCT:
      	drawLocalMapBase(g);
      	drawTurn(g);
      	drawConstructPanel(g);
      	break;
      case INFOMATION:
      	drawLocalMapBase(g);
      	drawTurn(g);
      	dc.drawDivStatus(g,fm,mapPoint,MARGINX,MARGINY,sy,backColor,textColor);
      	break;
      case TURNEND:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	drawYesNoButton(g);
      	drawInfo(g,TURNENDCONFIRM);
      	break;
    }
  }

//--------------------------------------------------------------------//
  void drawLocalMapBase(Graphics g){
// マップ描画
    dc.drawLocalMap(g);
    dc.drawDivisionLocal(g,textColor);
    if(mapPoint!=NONE)
      dc.drawStatus(g,fm,mapPoint,dc.viewSize+MARGINX,sy,fx-dc.viewSize,fy,sy);
    drawControlPanel(g);
  }

//--------------------------------------------------------------------//
  void drawTurn(Graphics g){
// ターン情報描画
    StringList list=new StringList(g,dc.viewSize+MARGINX,sy);
    list.setColor(dc.nation[dc.currentNation].color);
    list.drawString(dc.nation[dc.currentNation].name);
    list.tabString(dc.nation[dc.currentNation].name);
    list.setColor(textColor);
    list.space();
    list.drawString(TACTICS);
    list.tabString(TACTICS);
    list.space();
    list.space();
    list.drawStringNumber(TURN,turn,TURNMAX);
  }

//--------------------------------------------------------------------//
  void drawInfo(Graphics g,String string){
// 情報描画
    g.setColor(textColor);
    g.drawString(string,dc.viewSize+MARGINX,sy);
  }

//--------------------------------------------------------------------//
  void drawGlobalMap(Graphics g){
// 全体マップ描画
    dc.drawGlobalMap(g);
    dc.drawDivisionGlobal(g);
    if(mapPoint!=NONE)
      dc.drawStatus(g,fm,mapPoint,dc.viewSize+MARGINX,sy,fx-dc.viewSize,fy,sy);
    drawTurn(g);
    drawCursorGlobal(g);
  }

//--------------------------------------------------------------------//
  void drawDivisionList(Graphics g){
// 部隊リスト描画
    dc.drawDivisionList(g,fm,sy,indexViewRange,currentPage);
    drawCursorDivisionList(g);
    drawNextPageButton(g,divisionPage);
  }

//--------------------------------------------------------------------//
  void drawNationList(Graphics g){
// 国家リスト描画
    dc.drawNationList(g,sy,indexViewRange,currentPage);
    drawCursorNationList(g);
    drawNextPageButton(g,nationPage);
  }

//--------------------------------------------------------------------//
  void drawDivisionExchange(Graphics g,int x0,int y0,int xhalf,int sy){
// 部隊編成画面描画
    dc.drawDivisionExchange(g,x0,y0,xhalf,sy);
    drawCursorDivisionExchange(g);
    drawExchangePanel(g);
    drawDecidePanel(g);
  }

//--------------------------------------------------------------------//
  void drawSupply(Graphics g,int x0,int y0,int xhalf,int sy){
// 部隊補給画面描画
    dc.drawSupply(g,x0,y0,xhalf,sy);
    drawSupplyPanel(g);
    drawDecidePanel(g);
  }

//--------------------------------------------------------------------//
  void drawDivisionControlPanel(Graphics g){
// 部隊コントロールパネル表示
    int i,nati=dc.grid[mapPoint].nation,div=dc.grid[mapPoint].division;
    if(nati==dc.playerNation){
      switch(dc.nation[nati].division[div].status){
      	case WAIT:
      	  drawDivisionControlWait(g);
      	  break;
      	case MOVED:
      	  drawDivisionControlMoved(g);
      	  break;
      	case DONE:
      	  drawDivisionControlDone(g);
      	  break;
      }
    }
    else{
      drawDivisionControlEnemy(g);
    }
  }

//--------------------------------------------------------------------//
  void drawDivisionControlWait(Graphics g){
// 部隊コントロールパネル（待機時）表示
    divCntButton[MOVE].draw(g,backColor,textColor);
    drawDivisionControlMoved(g);
  }

//--------------------------------------------------------------------//
  void drawDivisionControlMoved(Graphics g){
// 部隊コントロールパネル（移動済時）表示
    int i;
    divCntButton[ATTACK].draw(g,backColor,textColor);
    divCntButton[DIRECTION].draw(g,backColor,textColor);
    divCntButton[FORMATION].draw(g,backColor,textColor);
    divCntButton[TRAINING].draw(g,backColor,textColor);
    divCntButton[INFOMATION].draw(g,backColor,textColor);
    divCntButton[ACTIONEND].draw(g,backColor,textColor);
    if(dc.gridNation(mapPoint)==dc.playerNation){
      divCntButton[SUPPLY].draw(g,backColor,textColor);
      divCntButton[CONSTRUCT].draw(g,backColor,textColor);
    }
    else if(dc.grid[mapPoint].castle){
      divCntButton[OCCUPY].draw(g,backColor,textColor);
    }
    else if(dc.canHide(mapPoint)){
      divCntButton[AMBUSH].draw(g,backColor,textColor);
    }
  }

//--------------------------------------------------------------------//
  void drawDivisionControlDone(Graphics g){
// 部隊コントロールパネル（行動済時）表示
    divCntButton[INFOMATION].draw(g,backColor,textColor);
    divCntButton[ACTIONDONE].draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawDivisionControlEnemy(Graphics g){
// 部隊コントロールパネル（敵部隊）表示
    divCntButton[INFOMATION].draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawConstructPanel(Graphics g){
// 建設パネル表示
    divCntButton[CONSTFOOD].draw(g,backColor,textColor);
    divCntButton[CONSTMONEY].draw(g,backColor,textColor);
    divCntButton[CONSTCASTLE].draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawControlPanel(Graphics g){
// コントロールパネル表示
    int i;
    for(i=0;i<cntPnlButton.length;i++){
      cntPnlButton[i].draw(g,backColor,textColor);
    }
  }

//--------------------------------------------------------------------//
  void drawYesNoButton(Graphics g){
// Yes/Noパネル表示
    yes.draw(g,backColor,textColor);
    no.draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawNextPageButton(Graphics g,int pageRange){
// 次ページボタン表示
    String page=""+currentPage+"/"+pageRange;
    nextPage.draw(g,backColor,textColor);
    g.drawString(page,fx-fm.stringWidth(page)-MARGINX,fy-MARGINY);
  }

//--------------------------------------------------------------------//
  void drawDecidePanel(Graphics g){
// 決定ボタンパネル表示
    decide.draw(g,backColor,textColor);
    cancel.draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawExchangePanel(Graphics g){
// 部隊編成ボタンパネル表示
    int i;
    for(i=0;i<6*DELTA.length;i++){
      exchangeButton[i].draw(g,backColor,textColor);
    }
  }

//--------------------------------------------------------------------//
  void drawSupplyPanel(Graphics g){
// 補給ボタンパネル表示
    int i;
    for(i=0;i<4*DELTA.length;i++){
      exchangeButton[i].draw(g,backColor,textColor);
    }
    soldierSupply.draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawCursorLocal(Graphics g){
// カーソルの描画
    int x0,y0;

    if(mousex>=dc.viewSize || mousey>=dc.viewSize) return;
    x0=(mousex/dc.gridSize)*dc.gridSize;
    y0=(mousey/dc.gridSize)*dc.gridSize;
    g.drawImage(dc.img.partImage[CURSOR],x0,y0,this);
  }

//--------------------------------------------------------------------//
  void drawCursorGlobal(Graphics g){
// 全体マップでのカーソルの描画
    int x0,y0,cx,cy;

    if(mousex>=dc.viewSize || mousey>=dc.viewSize) return;
    cx=dc.gridSize2*GRID;
    cy=dc.gridSize2*GRID;
    x0=(mousex/dc.gridSize2)*dc.gridSize2;
    x0=Math.min(Math.max(x0,cx/2),dc.gridSize2*dc.nx-cx/2);
    y0=(mousey/dc.gridSize2)*dc.gridSize2;
    y0=Math.min(Math.max(y0,cy/2),dc.gridSize2*dc.ny-cy/2);
    x0-=cx/2;
    y0-=cy/2;
    g.setColor(textColor);
    g.drawRect(x0,y0,cx,cy);
    g.drawRect(x0+1,y0+1,cx-2,cy-2);
  }

//--------------------------------------------------------------------//
  void drawCursorDivisionList(Graphics g){
// 部隊リストでのカーソルの描画
    int x0=1,y0,ofset=(currentPage-1)*indexViewRange;
    int maxIndex=Math.min(dc.nation[dc.currentNation].divisionNumber-ofset
                         ,indexViewRange);
    if(currentIndex<maxIndex){
      y0=currentIndex*sy+MARGINY/2;
      g.setColor(textColor);
      g.drawRect(x0,y0,fx-2,sy);
    }
  }

//--------------------------------------------------------------------//
  void drawCursorNationList(Graphics g){
// 国家リストでのカーソルの描画
    int x0=1,y0,ofset=(currentPage-1)*indexViewRange;

    if(currentIndex<Math.min(dc.nationNumber-ofset,indexViewRange)){
      y0=currentIndex*sy+MARGINY/2;
      g.setColor(textColor);
      g.drawRect(x0,y0,fx-2,sy);
    }
  }

//--------------------------------------------------------------------//
  void drawCursorDivisionExchange(Graphics g){
// 部隊編成画面でのカーソルの描画
    int indexMax,x0,y0;

    if(mousex<fx/2){
      x0=1;
      indexMax=dc.formation.generalNumber1();
    }
    else{
      x0=1+fx/2;
      indexMax=dc.formation.generalNumber2();
    }
    if(0<=currentIndex && currentIndex<indexMax){
      y0=(currentIndex+7)*sy+MARGINY/2;
      g.setColor(textColor);
      g.drawRect(x0,y0,fx/2-2,sy);
    }
  }

//--------------------------------------------------------------------//
  void drawError(Graphics g,String message){
// エラーメッセージ表示
    int sx=fm.stringWidth(message),sy=fm.getHeight();

    g.setColor(backColor);
    g.fillRect((fx-sx-MARGINX)/2,(fy-sy-MARGINY)/2,sx+MARGINX,sy+MARGINY);
    g.setColor(textColor);
    g.drawString(message,(fx-sx)/2,(fy+sy)/2);
  }
}

//--------------------------------------------------------------------//
// データ管理
class WCPDataCore extends Panel
  implements Parameters,DivisionStatus,Exchange{
  static final int MINIMUM=-10000;              // 最小値

  int game=GAME;                                // ゲーム状態
  int nationNumber;                             // 国家数
  int generalNumber;                            // 武将総数
  int weaponNumber;                             // 兵種数
  Nation nation[]=new Nation[NATIONMAX];        // 国家クラス
  General general[]=new General[GENERALMAX];    // 武将クラス
  Weapon weapon[]=new Weapon[WEAPONMAX];        // 兵種クラス
  ImageData img;                                // イメージクラス

  String fieldName;                             // フィールド名
  FieldParts fp[]=new FieldParts[FIELDMAX];     // フィールド部品クラス
  Castle castle[]=new Castle[CASTLEMAX];        // 城クラス
  Grid grid[]=new Grid[GRIDMAX];                // フィールドデータ
  Formation formation;                          // 部隊編成クラス
  Supply supply;                                // 部隊補給クラス
  int nx=20,ny=20;                              // フィールドのマス目の数
  int nfield,ifield;                            // フィールドデータ数
  int castleNumber;                             // 城データ数
  int viewx,viewy;                              // 視点位置
  int viewSize=1;                               // 地図表示部分の大きさ
  int gridSize=1,gridSize2=1;                   // マス目の大きさ
  int currentNation=0;                          // 現在行動している国家
  int currentDivision=NONE;                     // 現在選択している部隊
  int attackedNation=NONE;                      // 攻撃対象の部隊の所属国家
  int attackedDivision=NONE;                    // 攻撃対象の部隊
  int formDivision1=NONE;                       // 編成部隊
  int formDivision2=NONE;
  Color backColor,textColor;                    // 背景・文字表示色
  int movingPoint[]=new int[MOVING];            // 移動状態での部隊位置
  int movingDirection[]=new int[MOVING];        // 移動状態での部隊の方向
  int moving=0;                                 // 移動コマ数
  int playerNation=0;                           // プレイヤーの国家
  private boolean battle=false;                 // 戦闘中フラッグ
  int moveTarget=0;                             // 部隊の移動目標

  WCPDataCore(InputStream is,Image image,int imageSize
      	     ,Color backColor,Color textColor) throws IOException{
    this.backColor=backColor;
    this.textColor=textColor;
    img=new ImageData(image,imageSize);
    readData(is);
    setDivFlag();
  }

//--------------------------------------------------------------------//
  void readData(InputStream is) throws IOException{
// 全体データ読み込み
    boolean EndOfFile=false;
    StreamTokenizer st=new StreamTokenizer
      	      	      (new BufferedReader(new InputStreamReader(is)));
    st.eolIsSignificant(true);

    while(st.nextToken()!=StreamTokenizer.TT_WORD);
    fieldName=st.sval;
    while(!EndOfFile){
      switch (st.nextToken()){
      	default:
      	  EndOfFile=true;
      	  break;
      	case StreamTokenizer.TT_EOL:
      	  break;
      	case StreamTokenizer.TT_NUMBER:
      	  break;
      	case StreamTokenizer.TT_WORD:
      	  if(st.sval.equals("field")){             // フィールドデータ
      	    readFieldPartsData(st);
      	    readFieldData(st);
      	  }
      	  else if(st.sval.equals("castle")){       // 城データ
      	    readCastleData(st);
      	  }
      	  else if(st.sval.equals("general")){      // 武将データ
      	    readGeneralData(st);
      	  }
      	  else if(st.sval.equals("weapon")){       // 兵種データ
      	    readWeaponData(st);
      	  }
      	  else if(st.sval.equals("nation")){       // 国家データ
      	    readNationData(st);
      	  }
      	  break;
      }
    }
    is.close();
  }

//--------------------------------------------------------------------//
  void readFieldPartsData(StreamTokenizer st) throws IOException{
// フィールド部品データ読み込み
    String name;
    int array[]=new int[8];
    int i,ii,move,effect,image,rr,gg,bb;
    boolean hide;
    Color color;

    while(st.nextToken()!=StreamTokenizer.TT_NUMBER);
    ifield=(int)st.nval;
    for(i=0;i<ifield;i++){
      while(st.nextToken()!=StreamTokenizer.TT_WORD);
      name=st.sval;
      readIntNumbers(st,array,8);
      ii=array[0];
      move=array[1];
      effect=array[2];
      if(array[3]==0) hide=false;
      else            hide=true;
      image=array[4];
      rr=array[5];
      gg=array[6];
      bb=array[7];
      color=new Color(rr,gg,bb);
      fp[ii]=new FieldParts(name,move,effect,hide,img.partImage[image],color);
    }
  }

//--------------------------------------------------------------------//
  void readFieldData(StreamTokenizer st) throws IOException{
// フィールドデータ読み込み
    int i,ii=0,num,value;
    int array[]=new int[2];

    readIntNumbers(st,array,2);
    nx=array[0];
    ny=array[1];
    nfield=nx*ny;
    while(ii<nfield){
      readIntNumbers(st,array,2);
      num=array[0];
      value=array[1];
      for(i=0;i<num;i++){
      	grid[ii]=new Grid(ii%nx,ii/nx,value,NONE,NONE,NONE);
      	ii++;
      }
    }
  }

//--------------------------------------------------------------------//
  void readCastleData(StreamTokenizer st) throws IOException{
// 城データ読み込み
    String name;
    int array[]=new int[13];
    int i,x,y,ii,move,image,rr,gg,bb,nati,food,money,dfood,dmoney,defense;
    Color color;
    boolean EndOfPart=false;

    castleNumber=0;
    while(!EndOfPart){
      switch (st.nextToken()){
      	default:
      	  EndOfPart=true;
      	  break;
      	case StreamTokenizer.TT_EOL:
      	  break;
      	case StreamTokenizer.TT_NUMBER:
      	  break;
      	case StreamTokenizer.TT_WORD:
      	  if(st.sval.equals("end")){                     // 終了
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    EndOfPart=true;
      	  }
      	  else{
      	    name=st.sval;
      	    readIntNumbers(st,array,13);
      	    ii=array[0];
      	    x=array[1]-1;
      	    y=array[2]-1;
      	    move=array[3];
      	    image=array[4];
      	    rr=array[5];
      	    gg=array[6];
      	    bb=array[7];
      	    food=array[8];
      	    money=array[9];
      	    dfood=array[10];
      	    dmoney=array[11];
      	    defense=array[12];
      	    color=new Color(rr,gg,bb);
      	    castle[ii]=new Castle(name,move,img.partImage[image],color
      	      	      	      	 ,food,money,dfood,dmoney,defense,x,y);
      	    grid[nx*y+x].setCastle(castleNumber);
      	    castleNumber++;
      	  }
      }
    }
  }

//--------------------------------------------------------------------//
  void readGeneralData(StreamTokenizer st) throws IOException{
// 武将データ読み込み
    String name=null;
    int ip,politics,strategy,command,strength,charisma;
    int array[]=new int[5];
    boolean EndOfPart=false;

    generalNumber=0;
    while(!EndOfPart){
      switch (st.nextToken()){
      	default:
      	  EndOfPart=true;
      	  break;
      	case StreamTokenizer.TT_EOL:
      	  break;
      	case StreamTokenizer.TT_NUMBER:
      	  ip=(int)st.nval;
      	  while(st.nextToken()!=StreamTokenizer.TT_WORD);
      	  name=st.sval;
      	  readIntNumbers(st,array,5);
      	  politics=array[0];
      	  strategy=array[1];
      	  command=array[2];
      	  strength=array[3];
      	  charisma=array[4];
      	  general[ip]=new General(ip,name,politics,strategy,command
                                 ,strength,charisma);
      	  generalNumber++;
      	  break;
      	case StreamTokenizer.TT_WORD:
      	  if(st.sval.equals("end")){                     // 終了
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    EndOfPart=true;
      	  }
      }
    }
  }

//--------------------------------------------------------------------//
  void readWeaponData(StreamTokenizer st) throws IOException{
// 兵種データ読み込み
    String name=null;
    int ip,mv,at,range,def,cost;
    int array[]=new int[6];
    boolean EndOfPart=false,counter;

    weaponNumber=0;
    while(!EndOfPart){
      switch (st.nextToken()){
      	default:
      	  EndOfPart=true;
      	  break;
      	case StreamTokenizer.TT_EOL:
      	  break;
      	case StreamTokenizer.TT_NUMBER:
      	  ip=(int)st.nval;
      	  while(st.nextToken()!=StreamTokenizer.TT_WORD);
      	  name=st.sval;
      	  readIntNumbers(st,array,6);
      	  mv=array[0];
      	  at=array[1];
      	  range=array[2];
      	  counter=(array[3]!=0);
      	  def=array[4];
      	  cost=array[5];
      	  weapon[ip]=new Weapon(ip,name,mv,at,range,counter,def,cost);
      	  weaponNumber++;
      	  break;
      	case StreamTokenizer.TT_WORD:
      	  if(st.sval.equals("end")){                     // 終了
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    EndOfPart=true;
      	  }
      }
    }
  }

//--------------------------------------------------------------------//
  void readNationData(StreamTokenizer st) throws IOException{
// 国家データ読み込み
    int i,j;
    String aname=null,dname=null;
    int ip,king,cnum,dnum,cstl,num,trn,wpn,food,money,ngen,dx,dy;
    int array[]=new int[8];
    Color aColor;
    boolean EndOfPart=false;

    nationNumber=0;
    while(!EndOfPart){
      switch (st.nextToken()){
      	default:
      	  EndOfPart=true;
      	  break;
      	case StreamTokenizer.TT_EOL:
      	  break;
      	case StreamTokenizer.TT_NUMBER:
      	  break;
      	case StreamTokenizer.TT_WORD:
      	  if(st.sval.equals("end")){                     // 終了
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    EndOfPart=true;
      	  }
      	  else{
      	    aname=st.sval;
      	    readIntNumbers(st,array,6);
      	    king=array[0];
      	    cnum=array[1];
      	    dnum=array[2];
      	    aColor=new Color(array[3],array[4],array[5]);
      	    nation[nationNumber]=new Nation(aname,aColor,textColor);
      	    for(i=0;i<cnum;i++){
      	      while(st.nextToken()!=StreamTokenizer.TT_NUMBER);
      	      cstl=(int)st.nval;
      	      castle[cstl].setNation(nationNumber,aColor);
      	    }
      	    for(i=0;i<dnum;i++){
      	      while(st.nextToken()!=StreamTokenizer.TT_WORD);
      	      dname=st.sval;
      	      readIntNumbers(st,array,8);
      	      num=array[0];
      	      trn=array[1];
      	      wpn=array[2];
      	      food=array[3];
      	      money=array[4];
      	      ngen=array[5];
      	      dx=array[6]-1;
      	      dy=array[7]-1;
      	      nation[nationNumber].addDivision
                (i,dname,nationNumber,num,trn,food,money,dx,dy,NORTH
                ,weapon[wpn]);
      	      if(i==0){
      	      	general[king].setDivision(nationNumber,i);
      	      	general[king].setKing();
      	      	nation[nationNumber].addKing(general[king]);
      	      }
      	      for(j=0;j<ngen;j++){
      	      	while(st.nextToken()!=StreamTokenizer.TT_NUMBER);
      	      	ip=(int)st.nval;
      	      	general[ip].setDivision(nationNumber,i);
      	      	nation[nationNumber].addGeneral(i,general[ip]);
      	      }
      	    }
      	    nationNumber++;
      	  }
      }
    }
  }

//--------------------------------------------------------------------//
  void readIntNumbers(StreamTokenizer st,int array[],int n)
    throws IOException{
// 複数の整数の読み込み
    int i;
    for(i=0;i<n;i++){
      while(st.nextToken()!=StreamTokenizer.TT_NUMBER);
      array[i]=(int)st.nval;
    }
  }

//--------------------------------------------------------------------//
  void setDivFlag(){
// 部隊位置の設定
    int i,j;
    for(j=0;j<nationNumber;j++){
      for(i=0;i<nation[j].divisionNumber;i++){
      	grid[divisionPoint(j,i)].setDivision(j,i);
      }
    }
  }

//--------------------------------------------------------------------//
  void setPlayerNation(int nati){
// プレイヤーの国家の決定
    playerNation=nati;
  }

//--------------------------------------------------------------------//
  void setGridSize(int viewSize){
// マス目の大きさの設定
    this.viewSize=viewSize;
    gridSize=viewSize/GRID;
    gridSize2=Math.max(Math.min(viewSize/nx,viewSize/ny),1);
  }

//--------------------------------------------------------------------//
  void setViewPoint(int point){
// 視点の設定
    viewx=Math.min(Math.max(grid[point].x,GHALF),nx-GHALF);
    viewy=Math.min(Math.max(grid[point].y,GHALF),ny-GHALF);
  }

//--------------------------------------------------------------------//
  void setDivViewPoint(int nati,int div){
// 部隊位置に視点中心を設定
    currentDivision=div;
    viewx=Math.min(Math.max(nation[nati].pointX(div),GHALF),nx-GHALF);
    viewy=Math.min(Math.max(nation[nati].pointY(div),GHALF),ny-GHALF);
  }

//--------------------------------------------------------------------//
  void nextNation(){
// 次の国家
    if(currentNation!=NONE)
      currentNation=(currentNation+1)%nationNumber;
  }

//--------------------------------------------------------------------//
  int divisionPoint(int nati,int div){
// 部隊位置獲得
    return nx*nation[nati].pointY(div)+nation[nati].pointX(div);
  }

//--------------------------------------------------------------------//
  int divisionFieldEffect(int nati,int div){
// 部隊の地形効果
    int point=divisionPoint(nati,div);
    if(grid[point].castle) return castle[grid[point].field].effect;
    else                   return fp[grid[point].field].effect;
  }

//--------------------------------------------------------------------//
  int getMapPointLocal(int x,int y){
// フィールド位置の獲得
    int ix=0,iy=0;

    if(x>=viewSize || y>=viewSize) return NONE;
    ix=Math.min(Math.max(x/gridSize+viewx-GHALF,0),nx-1);
    iy=Math.min(Math.max(y/gridSize+viewy-GHALF,0),ny-1);
    return nx*iy+ix;
  }

//--------------------------------------------------------------------//
  int getMapPointGlobal(int x,int y){
// 全体マップでのフィールド位置の獲得
    int ix=0,iy=0;

    if(x>=viewSize || y>=viewSize) return NONE;
    ix=Math.min(Math.max(x/gridSize2,0),nx-1);
    iy=Math.min(Math.max(y/gridSize2,0),ny-1);
    return nx*iy+ix;
  }

//--------------------------------------------------------------------//
  int gridNation(int point){
// 領有している国家
    if(grid[point].castle){
      return castle[grid[point].field].nation;
    }
    else{
      return NONE;
    }
  }

//--------------------------------------------------------------------//
  boolean canHide(int point){
// 伏兵可能判定
    int nati=grid[point].nation,div=grid[point].division;
    int x=point%nx,y=point/nx;

    return canHide(nati,div,point,x,y);
  }

//--------------------------------------------------------------------//
  boolean canHide(int nati,int div){
// 伏兵可能判定
    int x=nation[nati].pointX(div),y=nation[nati].pointY(div);
    int point=y*nx+x;

    return canHide(nati,div,point,x,y);
  }

//--------------------------------------------------------------------//
  boolean canHide(int nati,int div,int point,int x,int y){
// 伏兵可能判定
    int nation4[]=new int[4];

    if(!grid[point].castle){
      if(fp[grid[point].field].hide){
      	if(y>0)    nation4[0]=grid[point-nx].nation;    // 北
      	else       nation4[0]=NONE;
      	if(y<ny-1) nation4[1]=grid[point+nx].nation;    // 南
      	else       nation4[1]=NONE;
      	if(x>0)    nation4[2]=grid[point-1].nation;     // 西
      	else       nation4[2]=NONE;
      	if(x<nx-1) nation4[3]=grid[point+1].nation;     // 東
      	else       nation4[3]=NONE;
      	if(nation4[0]!=NONE && nation4[0]!=nati) return false;
      	if(nation4[1]!=NONE && nation4[1]!=nati) return false;
      	if(nation4[2]!=NONE && nation4[2]!=nati) return false;
      	if(nation4[3]!=NONE && nation4[3]!=nati) return false;
      	return !nation[nati].isHide(div);
      }
    }
    return false;
  }

//--------------------------------------------------------------------//
  void setDirection(int point){
// 部隊方向の設定
    int dx,dy,direc;

    dx=grid[point].x-nation[currentNation].pointX(currentDivision);
    dy=grid[point].y-nation[currentNation].pointY(currentDivision);
    if(Math.abs(dx)>Math.abs(dy)){
      if(dx>0) direc=EAST;
      else     direc=WEST;
    }
    else{
      if(dy>0) direc=SOUTH;
      else     direc=NORTH;
    }
    nation[currentNation].setDirection(currentDivision,direc);
  }

//--------------------------------------------------------------------//
  void setCurrentDivision(int nation,int div){
// 行動中の国家の設定
    currentNation=nation;
    currentDivision=div;
  }

//--------------------------------------------------------------------//
  void setMoveDistance(int nati,int div){
// 部隊移動可能範囲の設定
    clearMoveDistance();
    FindDistance(nation[nati].pointX(div),nation[nati].pointY(div)
      	      	,nation[nati].division[div].move);
  }

//--------------------------------------------------------------------//
  int setMoveDistance(int point){
// 部隊移動可能範囲の設定
    int nati=grid[point].nation,div=grid[point].division;
    if(nati==currentNation && div!=NONE){
      setMoveDistance(nati,div);
    }
    currentDivision=div;
    return nati;
  }

//--------------------------------------------------------------------//
  void FindDistance(int x,int y,int dist){
// 移動可能範囲の計算
    int xy=y*nx+x,dnew;

    grid[xy].setMoveDistance(Math.max(grid[xy].moveDistance,dist));
    if(dist==0) return;
    if(y>0 && CheckMove(xy-nx,dist)){       // 北
      dnew=dist-Mobility(xy-nx);
      FindDistance(x,y-1,dnew);
    }
    if(y<ny-1 && CheckMove(xy+nx,dist)){    // 南
      dnew=dist-Mobility(xy+nx);
      FindDistance(x,y+1,dnew);
    }
    if(x>0 && CheckMove(xy-1,dist)){        // 西
      dnew=dist-Mobility(xy-1);
      FindDistance(x-1,y,dnew);
    }
    if(x<nx-1 && CheckMove(xy+1,dist)){     // 東
      dnew=dist-Mobility(xy+1);
      FindDistance(x+1,y,dnew);
    }
  }

//--------------------------------------------------------------------//
  boolean CheckMove(int xy,int dist){
// 移動可能の判定
    if(xy>=0){
      if(grid[xy].division==NONE && dist>=Mobility(xy)){
      	if(grid[xy].moveDistance<dist) return true;
      }
    }
    return false;
  }

//--------------------------------------------------------------------//
  int Mobility(int xy){
// 必要機動力
    int mobility;

    if(grid[xy].castle) mobility=castle[grid[xy].field].move;
    else                mobility=fp[grid[xy].field].move;
    return mobility;
  }

//--------------------------------------------------------------------//
  void setMoveDivision(int point){
// 部隊移動の設定
    moving=0;
    if(grid[point].moveDistance>=0){
      moveDivision(grid[point].x,grid[point].y,grid[point].moveDistance);
    }
    else{
      currentDivision=NONE;
    }
  }

//--------------------------------------------------------------------//
  void moveDivision(int x,int y,int dist){
// 部隊移動の計算
    int xy=y*nx+x;
    boolean hide=true;

    if(grid[xy].castle || !fp[grid[xy].field].hide) hide=false;
    while(dist!=nation[currentNation].division[currentDivision].move){
      movingPoint[moving]=xy;
      dist+=Mobility(xy);
      if(y>0 && grid[xy-nx].moveDistance==dist){
      	movingDirection[moving]=SOUTH;
      	xy-=nx;
      	y--;
      }
      else if(y<ny-1 && grid[xy+nx].moveDistance==dist){
      	movingDirection[moving]=NORTH;
      	xy+=nx;
      	y++;
      }
      else if(x>0 && grid[xy-1].moveDistance==dist){
      	movingDirection[moving]=EAST;
      	xy--;
      	x--;
      }
      else if(x<nx-1 && grid[xy+1].moveDistance==dist){
      	movingDirection[moving]=WEST;
      	xy++;
      	x++;
      }
      if(grid[xy].castle || !fp[grid[xy].field].hide) hide=false;
      moving++;
    }
    if(!hide) nation[currentNation].appear(currentDivision);
  }

//--------------------------------------------------------------------//
  void moveDraw(int step){
// 部隊移動描画
    int point,x,y;
    point=movingPoint[step];
    x=nation[currentNation].pointX(currentDivision);
    y=nation[currentNation].pointY(currentDivision);
    grid[nx*y+x].setDivision(NONE,NONE);
    grid[point].setDivision(currentNation,currentDivision);
    nation[currentNation].moveDivision
      (currentDivision,grid[point].x,grid[point].y,movingDirection[step]);
  }

//--------------------------------------------------------------------//
  void clearMoveDistance(){
// 部隊移動範囲の消去
    int i;
    for(i=0;i<nfield;i++){
      grid[i].setMoveDistance(NONE);
    }
  }

//--------------------------------------------------------------------//
  boolean setAttackDistance(int point){
// 部隊攻撃可能範囲の設定
    int nati=grid[point].nation,div=grid[point].division;
    if(nati==currentNation && div!=NONE){
      currentDivision=div;
      clearAttackDistance();
      FindAttack(grid[point].x,grid[point].y,nation[nati].AttackRange(div));
      return true;
    }
    else{
      currentDivision=NONE;
      return false;
    }
  }

//--------------------------------------------------------------------//
  void setAttackDistance(int point,int div){
// 部隊攻撃可能範囲の設定
    clearAttackDistance();
    FindAttack(grid[point].x,grid[point].y,nation[currentNation].AttackRange(div));
    grid[point].setAttackDistance(NONE);
  }

//--------------------------------------------------------------------//
  void FindAttack(int x,int y,int dist){
// 攻撃可能範囲の計算
    int xy,dnew;

    xy=y*nx+x;
    grid[xy].setAttackDistance(Math.max(grid[xy].attackDistance,dist));
    if(dist==0) return;
    dnew=dist-1;
    if(y>0 && CheckAttack(xy-nx,dist)){         // 北
      FindAttack(x,y-1,dnew);
    }
    if(y<ny-1 && CheckAttack(xy+nx,dist)){      // 南
      FindAttack(x,y+1,dnew);
    }
    if(x>0 && CheckAttack(xy-1,dist)){          // 西
      FindAttack(x-1,y,dnew);
    }
    if(x<nx-1 && CheckAttack(xy+1,dist)){       // 東
      FindAttack(x+1,y,dnew);
    }
  }

//--------------------------------------------------------------------//
  boolean CheckAttack(int xy,int dist){
// 攻撃可能の判定
    if(xy>=0){
      if(grid[xy].nation!=currentNation){
      	if(dist>0 && grid[xy].attackDistance<dist) return true;
      }
    }
    return false;
  }

//--------------------------------------------------------------------//
  void setAttackDivision(int point){
// 部隊攻撃の設定
    int nati=grid[point].nation,div=grid[point].division;
    if(grid[point].attackDistance>=0){
      if(nati!=currentNation && div!=NONE){
      	setDirection(point);
      	attackedNation=nati;
      	attackedDivision=div;
      	return;
      }
    }
    currentDivision=NONE;
  }

//--------------------------------------------------------------------//
  void setAttackDivision(int point,int nati,int div){
// 部隊攻撃の設定
    if(nati!=currentNation && div!=NONE){
      setDirection(point);
      attackedNation=nati;
      attackedDivision=div;
    }
  }

//--------------------------------------------------------------------//
  void attackDraw(int step){
// 部隊攻撃描画
    battle=!battle;
  }

//--------------------------------------------------------------------//
  void attackCalculate(){
// 部隊攻撃ダメージ計算
    double directionCoefficient;
    int i,direc;
    int attack1,defense1,field1,damage1,direc1;
    int attack2,defense2,field2,damage2,direc2;

    attack1=nation[currentNation].division[currentDivision].attack;
    defense1=nation[currentNation].division[currentDivision].defense;
    field1=divisionFieldEffect(currentNation,currentDivision);
    direc1=nation[currentNation].division[currentDivision].direction;
    attack2=nation[attackedNation].division[attackedDivision].attack;
    defense2=nation[attackedNation].division[attackedDivision].defense;
    field2=divisionFieldEffect(attackedNation,attackedDivision);
    direc2=nation[attackedNation].division[attackedDivision].direction;
    if(nation[currentNation].isHide(currentDivision)){  // 伏兵
      attack1*=AMBUSHCOEF;
      defense1*=AMBUSHCOEF;
    }
    direc=(direc1-direc2+4)%4;
    switch(direc){
      default:                                          // 側面攻撃
      	directionCoefficient=SIDECOEF;
      	break;
      case 0:                                           // 背後からの攻撃
      	directionCoefficient=BACKCOEF;
      	break;
      case 2:                                           // 正面攻撃
      	directionCoefficient=FRONTCOEF;
      	break;
    }
    damage1=attack1/(int)(directionCoefficient*defense2*field2);
    damage2=(int)(directionCoefficient*(attack2/(defense1*field1)));
    nation[attackedNation].Damage(attackedDivision,damage1);
    if(nation[currentNation].division[currentDivision].weapon.counter){
      nation[currentNation].Damage(currentDivision,damage2);
    }
    nation[currentNation].appear(currentDivision);
    deleteDivision(attackedNation,attackedDivision);
    deleteDivision(currentNation,currentDivision);
    battle=false;
    attackedDivision=NONE;
  }

//--------------------------------------------------------------------//
  void clearAttackDistance(){
// 部隊攻撃可能範囲の消去
    int i;
    for(i=0;i<nfield;i++){
      grid[i].setAttackDistance(NONE);
    }
  }

//--------------------------------------------------------------------//
  boolean setFormationPlace(int point){
// 編成対象位置の設定
    int nati=grid[point].nation,div=grid[point].division;
    if(nati==currentNation && div!=NONE){
      currentDivision=div;
      clearFormation();
      FindFormationPlace(grid[point].x,grid[point].y);
      return true;
    }
    else{
      currentDivision=NONE;
      return false;
    }
  }

//--------------------------------------------------------------------//
  void FindFormationPlace(int x,int y){
// 編成可能範囲の計算
    int xy;

    xy=nx*y+x;
    if(y>0 && CheckFormation(xy-nx)){           // 北
      grid[xy-nx].setFormationPlace();
    }
    if(y<ny-1 && CheckFormation(xy+nx)){        // 南
      grid[xy+nx].setFormationPlace();
    }
    if(x>0 && CheckFormation(xy-1)){            // 西
      grid[xy-1].setFormationPlace();
    }
    if(x<nx-1 && CheckFormation(xy+1)){         // 東
      grid[xy+1].setFormationPlace();
    }
  }

//--------------------------------------------------------------------//
  boolean CheckFormation(int xy){
// 編成可能の判定
    if(xy>=0){
      if(grid[xy].division==NONE){
      	return true;
      }
      else if(grid[xy].nation==currentNation && 
      	nation[currentNation].CheckFormation(currentDivision,grid[xy].division)){
      	return true;
      }
    }
    return false;
  }

//--------------------------------------------------------------------//
  void setFormationDivision(int point){
// 編成部隊の設定
    int nati=grid[point].nation,div=grid[point].division;
    if(grid[point].formation){
      formDivision1=currentDivision;
      formDivision2=grid[point].division;
    }
    else{
      currentDivision=NONE;
    }
  }

//--------------------------------------------------------------------//
  void clearFormation(){
// 編成部隊選択の解除
    int i;
    for(i=0;i<nfield;i++){
      grid[i].formationOff();
    }
  }

//--------------------------------------------------------------------//
  void setExchangeDivision(int point){
// 部隊編成の設定
    Division tempDivision;
    int i;

    if(formDivision2==NONE){
      tempDivision=new Division(nation[currentNation].divisionNumber,"null"
      	      	  ,currentNation,0,0,0,0,grid[point].x,grid[point].y
      	      	  ,NORTH,nation[currentNation].division[formDivision1].weapon);
      formation=new Formation(nation[currentNation].division[formDivision1]
      	      	      	     ,tempDivision);
    }
    else{
      formation=new Formation(nation[currentNation].division[formDivision1]
      	      	      	     ,nation[currentNation].division[formDivision2]);
    }
  }

//--------------------------------------------------------------------//
  void foodExchange(int direc,int food){
// 兵糧交換
    if(formation!=null){
      switch(direc){
      	case LEFTRIGHT:
      	  formation.foodExchange1(food);
      	  break;
      	case RIGHTLEFT:
      	  formation.foodExchange2(food);
      	  break;
      }
    }
  }

//--------------------------------------------------------------------//
  void moneyExchange(int direc,int money){
// 所持金交換
    if(formation!=null){
      switch(direc){
      	case LEFTRIGHT:
      	  formation.moneyExchange1(money);
      	  break;
      	case RIGHTLEFT:
      	  formation.moneyExchange2(money);
      	  break;
      }
    }
  }

//--------------------------------------------------------------------//
  void soldierExchange(int direc,int number){
// 兵士交換
    if(formation!=null){
      switch(direc){
      	case LEFTRIGHT:
      	  formation.soldierExchange1(number);
      	  break;
      	case RIGHTLEFT:
      	  formation.soldierExchange2(number);
      	  break;
      }
    }
  }

//--------------------------------------------------------------------//
  void generalExchange(int direc,int general){
// 武将交換
    if(formation!=null){
      switch(direc){
      	case LEFTRIGHT:
      	  formation.generalExchange1(general);
      	  break;
      	case RIGHTLEFT:
      	  formation.generalExchange2(general);
      	  break;
      }
    }
  }

//--------------------------------------------------------------------//
  void formationSet(int point){
// 部隊編成の決定
    if(formation==null) return;
    if(formation.soldierNumber1()>0 && formation.soldierNumber2()>0){
      nation[currentNation].resetDivision(formDivision1,formation.formDivision1);
      if(formDivision2==NONE){
      	formDivision2=nation[currentNation].divisionNumber;
      	nation[currentNation].addDivision(formDivision2,formation.formDivision2);
      	grid[point].setDivision(currentNation,formDivision2);
      }
      else{
      	nation[currentNation].resetDivision(formDivision2,formation.formDivision2);
      }
      currentDivision=formDivision2;
      actionDone();
      currentDivision=formDivision1;
      actionDone();
    }
    else if(formation.soldierNumber1()==0 && formation.generalNumber1()==0){
      if(formDivision2!=NONE){
      	nation[currentNation].resetDivision(formDivision1,formation.formDivision1);
      	nation[currentNation].resetDivision(formDivision2,formation.formDivision2);
      	currentDivision=formDivision2;
      	actionDone();
      	deleteDivision(currentNation,formDivision1);
      }
    }
    else if(formation.soldierNumber2()==0 && formation.generalNumber2()==0){
      if(formDivision2!=NONE){
      	nation[currentNation].resetDivision(formDivision1,formation.formDivision1);
      	nation[currentNation].resetDivision(formDivision2,formation.formDivision2);
      	currentDivision=formDivision1;
      	actionDone();
      	deleteDivision(currentNation,formDivision2);
      }
    }
    formationCancel();
  }

//--------------------------------------------------------------------//
  void formationCancel(){
// 部隊編成の取消
    formation=null;
    formDivision1=NONE;
    formDivision2=NONE;
  }

//--------------------------------------------------------------------//
  void setSupply(int point){
// 部隊補給の設定
    if(grid[point].castle){
      supply=new Supply(nation[currentNation].division[currentDivision]
      	      	       ,castle[grid[point].field]);
    }
  }

//--------------------------------------------------------------------//
  void foodSupply(int direc,int food){
// 兵糧補給
    if(supply!=null){
      switch(direc){
      	case LEFTRIGHT:
      	  supply.foodDivisionToCastle(food);
      	  break;
      	case RIGHTLEFT:
      	  supply.foodCastleToDivision(food);
      	  break;
      }
    }
  }

//--------------------------------------------------------------------//
  void moneySupply(int direc,int money){
// 資金補給
    if(supply!=null){
      switch(direc){
      	case LEFTRIGHT:
      	  supply.moneyDivisionToCastle(money);
      	  break;
      	case RIGHTLEFT:
      	  supply.moneyCastleToDivision(money);
      	  break;
      }
    }
  }

//--------------------------------------------------------------------//
  void soldierSupply(int point){
// 募兵
    if(supply!=null){
      if(supply.soldierSupply()) supplySet(point);
      else                       supplyCancel();
    }
  }

//--------------------------------------------------------------------//
  void supplySet(int point){
// 部隊補給の決定
    if(supply!=null){
      nation[currentNation].resetDivision(currentDivision,supply.division);
      castle[grid[point].field]=new Castle(supply.castle);
      castle[grid[point].field].setNation(supply.castle.nation
      	      	      	      	      	 ,supply.castle.nationColor);
      actionDone();
      supplyCancel();
    }
  }

//--------------------------------------------------------------------//
  void supplyCancel(){
// 部隊補給の取消
    supply=null;
  }

//--------------------------------------------------------------------//
  void constructFoodProduct(int point){
// 城の農業開発

    if(castle[grid[point].field].canFoodConstruct() &&
       nation[currentNation].useMoney(currentDivision,COST)){
      castle[grid[point].field].constructFoodProduct
      	(nation[currentNation].Construct(currentDivision));
      actionDone();
    }
  }

//--------------------------------------------------------------------//
  void constructMoneyProduct(int point){
// 城の商業開発
    if(castle[grid[point].field].canMoneyConstruct() &&
       nation[currentNation].useMoney(currentDivision,COST)){
      castle[grid[point].field].constructMoneyProduct
      	(nation[currentNation].Construct(currentDivision));
      actionDone();
    }
  }

//--------------------------------------------------------------------//
  void constructCastleClass(int point){
// 城の規模拡大
    if(castle[grid[point].field].canCastleConstruct() &&
       nation[currentNation].useMoney(currentDivision,COST)){
      castle[grid[point].field].constructCastleClass
      	(nation[currentNation].Construct(currentDivision));
      actionDone();
    }
  }

//--------------------------------------------------------------------//
  boolean Training(){
// 部隊訓練
    if(nation[currentNation].division[currentDivision].training
      <MAXPARAMETER){
      nation[currentNation].Training(currentDivision);
      actionDone();
      return true;
    }
    else{
      return false;
    }
  }

//--------------------------------------------------------------------//
  void occupyCastle(int point){
// 城の占領
    if(grid[point].castle){
      castle[grid[point].field].setNation(currentNation
      	      	      	      	      	 ,nation[currentNation].color);
      actionDone();
    }
  }

//--------------------------------------------------------------------//
  void findAttackDivision(int nati,int div){
// 攻撃可能部隊の探索
    int i,j,point,evalPoint=MINIMUM;

    setCurrentDivision(nati,div);
    attackedNation=NONE;
    attackedDivision=NONE;
    moveTarget=divisionPoint(nati,div);
    setMoveDistance(nati,div);
    for(i=0;i<nfield;i++){
      if(grid[i].moveDistance!=NONE){
      	setAttackDistance(i,div);
      	for(j=0;j<nfield;j++){
      	  if(grid[j].attackDistance!=NONE && grid[j].division!=NONE &&
      	     !nation[grid[j].nation].isHide(grid[j].division)){
      	    point=grid[i].moveDistance-grid[j].attackDistance;
      	    if(point>evalPoint){
      	      evalPoint=point;
      	      moveTarget=i;
      	      attackedNation=grid[j].nation;
      	      attackedDivision=grid[j].division;
      	    }
      	  }
      	}
      }
    }
  }

//--------------------------------------------------------------------//
  void ambushDivision(){
// 伏兵
    if(canHide(currentNation,currentDivision))
      nation[currentNation].ambush(currentDivision);
  }

//--------------------------------------------------------------------//
  void allWait(){
// 全部隊待機状態
    int i;
    for(i=0;i<nationNumber;i++){
      nation[i].allWait();
    }
  }

//--------------------------------------------------------------------//
  void actionWait(){
// 待機状態
    nation[currentNation].actionWait(currentDivision);
  }

//--------------------------------------------------------------------//
  void moveDone(){
// 移動終了
    nation[currentNation].moveDone(currentDivision);
  }

//--------------------------------------------------------------------//
  void actionDone(){
// 行動終了
    if(currentNation!=NONE && currentDivision!=NONE)
      nation[currentNation].actionDone(currentDivision);
  }

//--------------------------------------------------------------------//
  void nextTurn(){
// 次のターンへ
    int i,j,bonus,point;

    allWait();
    for(i=0;i<nationNumber;i++){  // 部隊の兵糧消費
      nation[i].eatFood();
    }
    for(i=0;i<castleNumber;i++){  // 城の生産
      castle[i].Product();
    }
    for(i=0;i<nationNumber;i++){  // 物資調達ボーナス
      for(j=0;j<nation[i].divisionNumber;j++){
      	if(grid[divisionPoint(i,j)].castle){
      	  point=grid[divisionPoint(i,j)].field;
      	  if(castle[point].nation==i){
      	    bonus=nation[i].division[j].Bonus();
      	    castle[point].SupplyFood(bonus);
      	    castle[point].SupplyMoney(bonus);
      	  }
      	}
      }
    }
  }

//--------------------------------------------------------------------//
  void deleteDivision(int nati,int div){
// 部隊削除
    int i,j,ndiv,ip;

    if(nation[nati].soldierNumber(div)==0){
      grid[divisionPoint(nati,div)].setDivision(NONE,NONE);
      for(i=div+1;i<nation[nati].divisionNumber;i++){
      	grid[divisionPoint(nati,i)].setDivision(nati,i-1);
      }
      if(div==ROYALDIVISION){                             // 第1部隊全滅
      	deleteNation(nati);
      }
      else{                                               // その他の部隊全滅
      	for(i=div+1;i<nation[nati].divisionNumber;i++){
      	  grid[divisionPoint(nati,i)].setDivision(nati,i-1);
      	}
      	ndiv=0;
      	for(i=0;i<nation[nati].generalNumber(div);i++){
      	  ip=nation[nati].division[div].general[i].id;
      	  while((nation[nati].generalNumber(ndiv)>=DIVGENERAL || 
      	      	ndiv==div) && ndiv<nation[nati].divisionNumber) ndiv++;
      	  if(ndiv<nation[nati].divisionNumber){
      	    general[ip].setDivision(nati,NONE);           // 部隊へ復帰
      	    nation[nati].addGeneral(ndiv,general[ip]);
      	  }
      	  else{
      	    general[ip].setDivision(NONE,NONE);           // 在野武将になる
      	  }
      	}
      	nation[nati].deleteDivision(div);
      }
    }
  }

//--------------------------------------------------------------------//
  void deleteNation(int nati){
// 国家削除
    int i,j,ip;

    for(i=0;i<nation[nati].divisionNumber;i++){
      for(j=0;j<nation[nati].generalNumber(i);j++){
      	ip=nation[nati].division[i].general[j].id;
      	general[ip].setDivision(NONE,NONE);           // 在野武将になる
      }
      grid[divisionPoint(nati,i)].setDivision(NONE,NONE);
    }
    nation[nati].deleteAllDivision();
    checkComplete(nati);

    nationNumber--;
    for(i=nati;i<nationNumber;i++){
      nation[i]=new Nation(nation[i+1]);
      if(i+1==playerNation)  playerNation=i;
      if(i+1==currentNation) currentNation=i;
      for(j=0;j<nation[i].divisionNumber;j++){
      	grid[divisionPoint(i,j)].setDivision(i,j);
      }
    }
    nation[nationNumber]=null;
  }

//--------------------------------------------------------------------//
  void checkComplete(int deletedNation){
// ゲームクリアのチェック
    int i,enemy=0;
    for(i=0;i<nationNumber;i++){
      if(i!=playerNation && nation[i].divisionNumber!=0) enemy++;
    }
    if(deletedNation==playerNation){
      gameOver();
    }
    else if(enemy==0){
      gameClear();
    }
    else if(deletedNation==currentNation){
      nextNation();
      currentDivision=NONE;
    }
  }

//--------------------------------------------------------------------//
  void gameClear(){
// ゲームクリア
    game=GAMEWIN;
    currentNation=NONE;
    currentDivision=NONE;
  }

//--------------------------------------------------------------------//
  void gameOver(){
// ゲームオーバー
    game=GAMEOVER;
    currentNation=NONE;
    currentDivision=NONE;
  }

//--------------------------------------------------------------------//
  void drawLocalMap(Graphics g){
// マップの描画
    int i,j,ii,jj,x0,y0;

    jj=viewy-GHALF;
    for(j=0;j<GRID;j++){
      y0=gridSize*j;
      ii=nx*jj+viewx-GHALF;
      for(i=0;i<GRID;i++){
      	x0=gridSize*i;
      	if(grid[ii].castle)
      	  g.drawImage(castle[grid[ii].field].image,x0,y0
      	      	     ,gridSize,gridSize,this);
      	else
      	  g.drawImage(fp[grid[ii].field].image,x0,y0
      	      	     ,gridSize,gridSize,this);
      	ii++;
      }
      jj++;
    }
  }

//--------------------------------------------------------------------//
  void drawGlobalMap(Graphics g){
// 全体マップの描画
    int i,j,ii,point,x0,y0;

    ii=0;
    for(j=0;j<ny;j++){
      y0=gridSize2*j;
      for(i=0;i<nx;i++){
      	x0=gridSize2*i;
      	point=grid[ii].field;
      	if(grid[ii].castle){
      	  g.setColor(castle[point].color);
      	  g.fillRect(x0,y0,gridSize2,gridSize2);
      	  if(castle[point].nation!=NONE){
      	    g.setColor(castle[point].nationColor);
      	    g.drawRect(x0+1,y0+1,gridSize2-2,gridSize2-2);
      	  }
      	}
      	else{
      	  g.setColor(fp[point].color);
      	  g.fillRect(x0,y0,gridSize2,gridSize2);
      	}
      	ii++;
      }
    }
  }

//--------------------------------------------------------------------//
  void drawDivisionLocal(Graphics g,Color frameColor){
// 部隊の描画
    int i,j,x0,y0;

    for(j=0;j<nationNumber;j++){
      for(i=0;i<nation[j].divisionNumber;i++){
      	x0=gridSize*(nation[j].pointX(i)-viewx+GHALF);
      	y0=gridSize*(nation[j].pointY(i)-viewy+GHALF);
      	if(x0<viewSize && y0<viewSize){
      	  nation[j].drawDivisionLocal(g,i,gridSize,x0,y0);
      	}
      }
    }
    if(battle){
      g.setColor(frameColor);
      x0=gridSize*(nation[currentNation].pointX(currentDivision)-viewx+GHALF);
      y0=gridSize*(nation[currentNation].pointY(currentDivision)-viewy+GHALF);
      g.fillRect(x0,y0,gridSize,gridSize);
      if(attackedDivision!=NONE){
      	x0=gridSize*(nation[attackedNation].pointX(attackedDivision)
      	      	    -viewx+GHALF);
      	y0=gridSize*(nation[attackedNation].pointY(attackedDivision)
      	      	    -viewy+GHALF);
      	g.fillRect(x0,y0,gridSize,gridSize);
      }
    }
  }

//--------------------------------------------------------------------//
  void drawDivisionGlobal(Graphics g){
// 全体マップでの部隊の描画
    int i,j,x0,y0;

    for(i=0;i<nationNumber;i++){
      for(j=0;j<nation[i].divisionNumber;j++){
      	x0=gridSize2*nation[i].pointX(j);
      	y0=gridSize2*nation[i].pointY(j);
      	nation[i].drawDivisionGlobal(g,j,gridSize2,x0,y0);
      }
    }
  }

//--------------------------------------------------------------------//
  void drawMoveDistance(Graphics g){
// 移動範囲の描画
    int i,j,ii,jj,gxy,x0,y0;

    jj=viewy-GHALF;
    for(j=0;j<GRID;j++){
      y0=gridSize*j;
      ii=nx*jj+viewx-GHALF;
      for(i=0;i<GRID;i++){
      	x0=gridSize*i;
      	if(grid[ii].moveDistance>=0 && 
      	   grid[ii].division!=currentDivision){
      	  g.drawImage(img.partImage[SELECTEDAREA],x0,y0,this);
      	}
      	ii++;
      }
      jj++;
    }
  }

//--------------------------------------------------------------------//
  void drawAttackDistance(Graphics g){
// 攻撃可能範囲の描画
    int i,j,ii,jj,gxy,x0,y0;

    jj=viewy-GHALF;
    for(j=0;j<GRID;j++){
      y0=gridSize*j;
      ii=nx*jj+viewx-GHALF;
      for(i=0;i<GRID;i++){
      	x0=gridSize*i;
      	if(grid[ii].attackDistance>=0 && 
      	   grid[ii].division!=currentDivision){
      	  g.drawImage(img.partImage[SELECTEDAREA],x0,y0,this);
      	}
      	ii++;
      }
      jj++;
    }
  }

//--------------------------------------------------------------------//
  void drawFormationPlace(Graphics g){
// 編成可能位置の描画
    int i,j,ii,jj,gxy,x0,y0;

    jj=viewy-GHALF;
    for(j=0;j<GRID;j++){
      y0=gridSize*j;
      ii=nx*jj+viewx-GHALF;
      for(i=0;i<GRID;i++){
      	x0=gridSize*i;
      	if(grid[ii].formation){
      	  g.drawImage(img.partImage[SELECTEDAREA],x0,y0,this);
      	}
      	ii++;
      }
      jj++;
    }
  }

//--------------------------------------------------------------------//
  void drawNationList(Graphics g,int sy,int indexViewRange,int currentPage){
// 国家リストの描画
    int i,x0=5,y0=0,ofset=(currentPage-1)*indexViewRange;

    for(i=ofset;i<Math.min(nationNumber,ofset+indexViewRange);i++){
      if(nation[i].divisionNumber>0){
      	y0+=sy;
      	nation[i].drawNationList(g,x0,y0);
      }
    }
  }

//--------------------------------------------------------------------//
  void drawDivisionList(Graphics g,FontMetrics fm,int sy,int indexViewRange
                       ,int currentPage){
// 部隊リストの描画
    int i,x0=5,y0=0,ofset=(currentPage-1)*indexViewRange;
    int maxIndex=Math.min(nation[currentNation].divisionNumber
                         ,ofset+indexViewRange);

    for(i=ofset;i<maxIndex;i++){
      y0+=sy;
      nation[currentNation].drawDivisionList(g,fm,i,x0,y0);
    }
  }

//--------------------------------------------------------------------//
  void drawDivisionExchange(Graphics g,int x0,int y0,int xhalf,int sy){
// 部隊編成の描画
    g.setColor(nation[currentNation].color);
    g.drawString(nation[currentNation].name,x0,y0);
    g.setColor(textColor);
    formation.drawDivisionExchange(g,x0,y0+sy,xhalf,sy);
  }

//--------------------------------------------------------------------//
  void drawSupply(Graphics g,int x0,int y0,int xhalf,int sy){
// 部隊補給の描画
    g.setColor(nation[currentNation].color);
    g.drawString(nation[currentNation].name,x0,y0);
    g.setColor(textColor);
    supply.drawSupply(g,x0,y0+sy,xhalf,sy);
  }

//--------------------------------------------------------------------//
  void drawStatus(Graphics g,FontMetrics fm,int point,int x0,int y0
                 ,int fx,int fy,int sy){
// ステータスの描画
    int nati=grid[point].nation,div=grid[point].division;

    g.setColor(backColor);
    g.fillRect(x0,y0,fx,fy);
    if(div!=NONE){
      drawDivStatus(g,fm,nati,div,x0,y0,sy);
      y0+=6*sy;
    }
    drawFieldStatus(g,fm,point,x0,y0,sy);
  }

//--------------------------------------------------------------------//
  void drawFieldStatus(Graphics g,FontMetrics fm,int point,int x0,int y0
                      ,int sy){
// 地形情報の描画
    g.setColor(textColor);
    if(grid[point].castle){
      castle[grid[point].field].drawParameter(g,fm,x0,y0,sy,grid[point].x,grid[point].y
      	      	      	      	      	     ,textColor);
    }
    else{
      fp[grid[point].field].drawParameter(g,fm,x0,y0,sy,grid[point].x,grid[point].y);
    }
  }

//--------------------------------------------------------------------//
  void drawDivStatus(Graphics g,FontMetrics fm,int nati,int div
                    ,int x0,int y0,int sy){
// 部隊情報の描画
    nation[nati].drawParameter(g,fm,div,x0,y0+sy,sy,textColor);
  }

//--------------------------------------------------------------------//
  void drawDivStatus(Graphics g,FontMetrics fm,int point,int x0,int y0
                    ,int sy,Color backColor,Color textColor){
// 部隊情報の描画
    int nati=grid[point].nation,div=grid[point].division;
    nation[nati].drawParameter(g,fm,div,x0,y0,sy,backColor,textColor);
  }
}

//--------------------------------------------------------------------//
// 部隊編成クラス
class Formation implements Parameters{
  Division formDivision1,formDivision2; // 編成部隊

  Formation(Division division1,Division division2){
    int i;

    formDivision1=new Division(division1.id,division1);
    for(i=0;i<division1.generalNumber;i++){
      formDivision1.addGeneral(division1.general[i]);
    }
    formDivision2=new Division(division2.id,division2);
    for(i=0;i<division2.generalNumber;i++){
      formDivision2.addGeneral(division2.general[i]);
    }
  }

//--------------------------------------------------------------------//
  void foodExchange1(int food){
// 兵糧交換
    int foodloss;

    food=Math.min(Math.max((formDivision1.food-1)%food+1,0)
                 ,formDivision2.FoodSupplyLimit());
    foodloss=-food;
    formDivision1.SupplyFood(foodloss);
    formDivision2.SupplyFood(food);
  }

//--------------------------------------------------------------------//
  void foodExchange2(int food){
// 兵糧交換
    int foodloss;

    food=Math.min(Math.max((formDivision2.food-1)%food+1,0)
                 ,formDivision1.FoodSupplyLimit());
    foodloss=-food;
    formDivision1.SupplyFood(food);
    formDivision2.SupplyFood(foodloss);
  }

//--------------------------------------------------------------------//
  void moneyExchange1(int money){
// 所持金交換
    int moneyloss;

    money=Math.min(Math.max((formDivision1.money-1)%money+1,0)
                  ,formDivision2.MoneySupplyLimit());
    moneyloss=-money;
    formDivision1.SupplyMoney(moneyloss);
    formDivision2.SupplyMoney(money);
  }

//--------------------------------------------------------------------//
  void moneyExchange2(int money){
// 所持金交換
    int moneyloss;

    money=Math.min(Math.max((formDivision2.money-1)%money+1,0)
                  ,formDivision1.MoneySupplyLimit());
    moneyloss=-money;
    formDivision1.SupplyMoney(money);
    formDivision2.SupplyMoney(moneyloss);
  }

//--------------------------------------------------------------------//
  void soldierExchange1(int number){
// 兵士交換
    number=Math.min(Math.max((formDivision1.soldierNumber-1)%number+1,0)
                   ,formDivision2.SoldierSupplyLimit());
    formDivision2.SupplySoldier(number,formDivision1.training);
    formDivision1.Damage(number);
  }

//--------------------------------------------------------------------//
  void soldierExchange2(int number){
// 兵士交換
    number=Math.min(Math.max((formDivision2.soldierNumber-1)%number+1,0)
                   ,formDivision1.SoldierSupplyLimit());
    formDivision1.SupplySoldier(number,formDivision2.training);
    formDivision2.Damage(number);
  }

//--------------------------------------------------------------------//
  void generalExchange1(int general){
// 武将交換
    if(!formDivision1.general[general].king &&
      	formDivision1.generalNumber>0 &&
      	formDivision2.generalNumber<DIVGENERAL){
      formDivision2.addGeneral(formDivision1.general[general]);
      formDivision1.deleteGeneral(general);
    }
  }

//--------------------------------------------------------------------//
  void generalExchange2(int general){
// 武将交換
    if(!formDivision2.general[general].king &&
      	formDivision2.generalNumber>0 &&
      	formDivision1.generalNumber<DIVGENERAL){
      formDivision1.addGeneral(formDivision2.general[general]);
      formDivision2.deleteGeneral(general);
    }
  }

//--------------------------------------------------------------------//
  int soldierNumber1(){
// 兵士数
    return formDivision1.soldierNumber;
  }

//--------------------------------------------------------------------//
  int soldierNumber2(){
// 兵士数
    return formDivision2.soldierNumber;
  }

//--------------------------------------------------------------------//
  int generalNumber1(){
// 武将数
    return formDivision1.generalNumber;
  }

//--------------------------------------------------------------------//
  int generalNumber2(){
// 武将数
    return formDivision2.generalNumber;
  }

//--------------------------------------------------------------------//
  void drawDivisionExchange(Graphics g,int x0,int y0,int xhalf,int sy){
// 部隊編成の描画
    formDivision1.drawDivisionExchange(g,x0,y0,sy);
    formDivision2.drawDivisionExchange(g,x0+xhalf,y0,sy);
  }
}

//--------------------------------------------------------------------//
// 部隊補給クラス
class Supply implements Parameters{
  Division division;    // 補給部隊
  Castle castle;        // 補給する城

  Supply(Division division,Castle castle){
    int i;

    this.division=new Division(division.id,division);
    for(i=0;i<division.generalNumber;i++){
      this.division.addGeneral(division.general[i]);
    }
    this.castle=new Castle(castle);
    this.castle.setNation(castle.nation,castle.nationColor);
  }

//--------------------------------------------------------------------//
  void foodDivisionToCastle(int food){
// 兵糧交換
    int foodloss;

    food=Math.min(Math.max((division.food-1)%food+1,0)
                 ,castle.FoodSupplyLimit());
    foodloss=-food;
    division.SupplyFood(foodloss);
    castle.SupplyFood(food);
  }

//--------------------------------------------------------------------//
  void foodCastleToDivision(int food){
// 兵糧交換
    int foodloss;

    food=Math.min(Math.max((castle.food-1)%food+1,0)
                 ,division.FoodSupplyLimit());
    foodloss=-food;
    division.SupplyFood(food);
    castle.SupplyFood(foodloss);
  }

//--------------------------------------------------------------------//
  void moneyDivisionToCastle(int money){
// 資金交換
    int moneyloss;

    money=Math.min(Math.max((division.money-1)%money+1,0)
                  ,castle.MoneySupplyLimit());
    moneyloss=-money;
    division.SupplyMoney(moneyloss);
    castle.SupplyMoney(money);
  }

//--------------------------------------------------------------------//
  void moneyCastleToDivision(int money){
// 資金交換
    int moneyloss;

    money=Math.min(Math.max((castle.money-1)%money+1,0)
                  ,division.MoneySupplyLimit());
    moneyloss=-money;
    division.SupplyMoney(money);
    castle.SupplyMoney(moneyloss);
  }

//--------------------------------------------------------------------//
  boolean soldierSupply(){
// 募兵
    if(division.useMoney(division.weapon.cost)){
      int soldier=castle.SupplySoldier(division.getSoldier());
      division.SupplySoldier(soldier,NEWSOLDIER);
      return true;
    }
    else{
      return false;
    }
  }

//--------------------------------------------------------------------//
  void drawSupply(Graphics g,int x0,int y0,int xhalf,int sy){
// 部隊補給の描画
    division.drawDivisionExchange(g,x0,y0,sy);
    castle.drawSupply(g,x0+xhalf,y0,sy);
  }
}

//--------------------------------------------------------------------//
// フィールド部品クラス
class FieldParts extends Panel implements Parameters,Words{
  String name;  // フィールド部品名
  int move;     // 移動必要機動力
  int effect;   // 地形効果
  boolean hide; // 伏兵可能スイッチ
  Image image;  // イメージ
  Color color;  // 表示色

  FieldParts(String name,int move,boolean hide,Image image,Color color){
    this.name=name;
    this.move=move;
    this.hide=hide;
    this.image=image;
    this.color=color;
  }

  FieldParts(String name,int move,int effect,boolean hide,Image image,Color color){
    this(name,move,hide,image,color);
    this.effect=effect;
  }

//--------------------------------------------------------------------//
  void drawParameter(Graphics g,FontMetrics fm,int x0,int y0,int sy
      	      	    ,int x,int y){
// 地形情報の表示
    int gx=image.getWidth(this),gy=image.getHeight(this),x1,range;
    x++; y++;
    g.drawImage(image,x0,y0+MARGINY,this);
    x0+=gx+MARGINX;
    y0+=sy;

    x1=x0+Math.max(fm.stringWidth(MOVENEED),fm.stringWidth(EFFECT));
    range=Math.max(MOVEMAX,EFFECTMAX);

    StringList list=new StringList(g,x0,y0);
    list.drawStringNumber(name+" x =",x,COORDMAX);
    list.space();
    list.drawStringNumber("y =",y,COORDMAX);
    list.lineFeed(sy);
    list.drawString(MOVENEED);
    list.setPosition(x1);
    if(move>MOVEMAX){
      list.drawString("∞",""+range);
    }
    else{
      list.drawNumber(move,range);
    }
    list.lineFeed(sy);
    list.drawString(EFFECT);
    list.setPosition(x1);
    list.drawNumber(effect,range);
  }
}

//--------------------------------------------------------------------//
// 城クラス
class Castle extends FieldParts{
  int food;                           // 兵糧
  int money;                          // 資金
  int foodProduct;                    // 農業生産
  int moneyProduct;                   // 商業生産
  int castleClass;                    // 城郭規模
  int x,y;                            // 城の位置
  int nation=NONE;                    // 所有している国家
  Color nationColor;                  // 所有している国家の色

  Castle(String name,int move,Image image,Color color,int food,int money
      	,int foodProduct,int moneyProduct,int castleClass,int x,int y){
    super(name,move,false,image,color);
    this.food=Math.min(food,MAXNUMBER);
    this.money=Math.min(money,MAXNUMBER);
    this.foodProduct=Math.min(foodProduct,MAXCLASS);
    this.moneyProduct=Math.min(moneyProduct,MAXCLASS);
    this.castleClass=Math.min(castleClass,MAXCLASS);
    this.x=x;
    this.y=y;
    effect=castleEffect(castleClass);
  }

  Castle(Castle castle){
    this(castle.name,castle.move,castle.image,castle.color
      	,castle.food,castle.money,castle.foodProduct,castle.moneyProduct
      	,castle.castleClass,castle.x,castle.y);
  }

//--------------------------------------------------------------------//
  void setNation(int nation,Color nationColor){
// 所有している国家の設定
    this.nation=nation;
    this.nationColor=nationColor;
  }

//--------------------------------------------------------------------//
  void SupplyFood(int supply){
// 兵糧補充
    food=Math.max(Math.min(food+supply,MAXNUMBER),0);
  }

//--------------------------------------------------------------------//
  void SupplyMoney(int supply){
// 資金補充
    money=Math.max(Math.min(money+supply,MAXNUMBER),0);
  }

//--------------------------------------------------------------------//
  int SupplySoldier(int divisionAbility){
// 兵士補充
    return 10*divisionAbility*castleClass/MAXCLASS;
  }

//--------------------------------------------------------------------//
  int FoodSupplyLimit(){
// 兵糧補充可能量
    return MAXNUMBER-food;
  }

//--------------------------------------------------------------------//
  int MoneySupplyLimit(){
// 資金補充可能量
    return MAXNUMBER-money;
  }

//--------------------------------------------------------------------//
  void Product(){
// 生産
    food=Math.min(food+foodProduct,MAXNUMBER);
    money=Math.min(money+moneyProduct,MAXNUMBER);
  }

//--------------------------------------------------------------------//
  void constructFoodProduct(int construct){
// 城の農業開発
    foodProduct=Math.min(foodProduct+construct,MAXCLASS);
  }

//--------------------------------------------------------------------//
  void constructMoneyProduct(int construct){
// 城の商業開発
    moneyProduct=Math.min(moneyProduct+construct,MAXCLASS);
  }

//--------------------------------------------------------------------//
  void constructCastleClass(int construct){
// 城の規模拡大
    castleClass=Math.min(castleClass+construct,MAXCLASS);
    effect=castleEffect(castleClass);
  }

//--------------------------------------------------------------------//
  boolean canFoodConstruct(){
// 農業開発可能
    return (foodProduct<MAXCLASS);
  }

//--------------------------------------------------------------------//
  boolean canMoneyConstruct(){
// 商業開発可能
    return (moneyProduct<MAXCLASS);
  }

//--------------------------------------------------------------------//
  boolean canCastleConstruct(){
// 城郭開発可能
    return (castleClass<MAXCLASS);
  }

//--------------------------------------------------------------------//
  int castleEffect(int castleClass){
// 城の地形効果
    return 3+(int)(3.0*Math.sqrt((double)castleClass/(double)MAXCLASS));
  }

//--------------------------------------------------------------------//
  void drawParameter(Graphics g,FontMetrics fm,int x0,int y0,int sy
                    ,int x,int y,Color textColor){
// 城情報の表示
    int sx1,sx2,sx3,x1;
    int gx=image.getWidth(this),gy=image.getHeight(this);

    drawParameter(g,fm,x0,y0,sy,x,y);
    if(nation!=NONE){
      g.setColor(nationColor);
      g.drawRect(x0,y0+MARGINY,gx,gy);
      g.setColor(textColor);
    }

    sx1=fm.stringWidth(FOODLABEL+MAXNUMBER);
    sx2=fm.stringWidth(MONEYLABEL+MAXNUMBER);
    sx3=fm.stringWidth(CASTLECLASS+MAXCLASS);
    x1=x0+MARGINX+Math.max(Math.max(sx1,sx2),sx3);
    y0+=Math.max(gy,3*sy)+sy;

    StringList list=new StringList(g,x0,y0);
    list.drawStringNumber(FOODLABEL,food,MAXNUMBER);
    list.setPosition(x1);
    list.drawStringNumber(FOODPRODUCT,foodProduct,MAXCLASS);
    list.lineFeed(sy);
    list.drawStringNumber(MONEYLABEL,money,MAXNUMBER);
    list.setPosition(x1);
    list.drawStringNumber(MONEYPRODUCT,moneyProduct,MAXCLASS);
    list.lineFeed(sy);
    list.setPosition(x1);
    list.drawStringNumber(CASTLECLASS,castleClass,MAXCLASS);
  }

//--------------------------------------------------------------------//
  void drawSupply(Graphics g,int x0,int y0,int sy){
// 部隊補給の描画
    g.drawString(name,x0,y0);
    g.drawString(FOODLABEL+" "+food,x0,y0+sy);
    g.drawString(MONEYLABEL+" "+money,x0,y0+2*sy);
  }
}

//--------------------------------------------------------------------//
// フィールドデータクラス
class Grid implements Parameters{
  int x,y;                  // グリッド座標
  int field;                // フィールドデータ
  int nation=NONE;          // 領有国家
  int division;             // 部隊位置フラッグ
  int moveDistance;         // 移動距離フラッグ
  int attackDistance;       // 攻撃距離フラッグ
  boolean formation=false;  // 編成フラッグ
  boolean castle=false;     // 城フラッグ

  Grid(int x,int y,int field,int division,int moveDistance,int attackDistance){
    this.x=x;
    this.y=y;
    this.field=field;
    this.division=division;
    this.moveDistance=moveDistance;
    this.attackDistance=attackDistance;
  }

//--------------------------------------------------------------------//
  void setCastle(int index){
// 城設置
    field=index;
    castle=true;
  }

//--------------------------------------------------------------------//
  void setDivision(int nation,int division){
// 部隊設置
    this.nation=nation;
    this.division=division;
  }

//--------------------------------------------------------------------//
  void setMoveDistance(int moveDistance){
// 移動距離設定
    this.moveDistance=moveDistance;
  }

//--------------------------------------------------------------------//
  void setAttackDistance(int attackDistance){
// 攻撃範囲設定
    this.attackDistance=attackDistance;
  }

//--------------------------------------------------------------------//
  void setFormationPlace(){
// 編成位置設定
    formation=true;
  }

//--------------------------------------------------------------------//
  void formationOff(){
// 編成解除
    formation=false;
  }
}

//--------------------------------------------------------------------//
// 国家クラス
class Nation implements Parameters,Words{
  String name,kingName;                         // 国家名・王の名
  Color color,textColor;                        // 国家色
  int divisionNumber=0;                         // 国家内の部隊数
  Division division[]=new Division[NATIONDIV];  // 部隊クラス

  Nation(String name,Color color,Color textColor){
    this.name=name;
    this.color=color;
    this.textColor=textColor;
  }

  Nation(Nation nation){
    this(nation.name,nation.color,nation.textColor);
    int i;
    for(i=0;i<nation.divisionNumber;i++){
      addDivision(nation.division[i].id,nation.division[i]);
    }
  }

//--------------------------------------------------------------------//
  void addDivision(int id,String name,int nation,int soldierNumber,int training
      	      	  ,int food,int money,int x,int y,int direction
      	      	  ,Weapon weapon){
// 部隊の追加
    division[id]=new Division(id,name,nation,soldierNumber,training,food,money
      	      	      	     ,x,y,direction,weapon);
    divisionNumber++;
  }

//--------------------------------------------------------------------//
  void addDivision(int id,Division div){
// 部隊の追加
    int i;
    division[id]=new Division(id,div);
    for(i=0;i<div.generalNumber;i++){
      division[id].addGeneral(div.general[i]);
      if(div.general[i].king) kingName=div.general[i].name;
    }
    divisionNumber++;
  }

//--------------------------------------------------------------------//
  void resetDivision(int id,Division div){
// 部隊の再設定
    int i;
    division[id]=new Division(id,div);
    for(i=0;i<div.generalNumber;i++){
      division[id].addGeneral(div.general[i]);
      if(div.general[i].king) kingName=div.general[i].name;
    }
  }

//--------------------------------------------------------------------//
  void deleteDivision(int id){
// 部隊の削除
    int i;

    divisionNumber--;
    for(i=id;i<divisionNumber;i++){
      resetDivision(i,division[i+1]);
      division[i].setStatus(division[i+1].status);
    }
    division[divisionNumber]=null;
  }

//--------------------------------------------------------------------//
  void deleteAllDivision(){
// 全部隊の削除
    int i;

    for(i=0;i<divisionNumber;i++){
      division[i]=null;
    }
    divisionNumber=0;
  }

//--------------------------------------------------------------------//
  void addKing(General king){
// 国王の設定
    division[ROYALDIVISION].addGeneral(king);
    kingName=king.name;
  }

//--------------------------------------------------------------------//
  void addGeneral(int div,General gen){
// 部隊所属将軍の追加
    division[div].addGeneral(gen);
  }

//--------------------------------------------------------------------//
  int generalNumber(int div){
// 武将数
    return division[div].generalNumber;
  }

//--------------------------------------------------------------------//
  int soldierNumber(int div){
// 兵士数
    return division[div].soldierNumber;
  }

//--------------------------------------------------------------------//
  int pointX(int div){
// 部隊の位置
    return division[div].x;
  }

//--------------------------------------------------------------------//
  int pointY(int div){
// 部隊の位置
    return division[div].y;
  }

//--------------------------------------------------------------------//
  void moveDivision(int div,int x,int y,int direction){
// 部隊の移動
    division[div].moveDivision(x,y,direction);
  }

//--------------------------------------------------------------------//
  void setDirection(int div,int direction){
// 部隊の方向転換
    division[div].setDirection(direction);
  }

//--------------------------------------------------------------------//
  void allWait(){
// 全部隊待機状態
    int i;
    for(i=0;i<divisionNumber;i++){
      actionWait(i);
    }
  }

//--------------------------------------------------------------------//
  void actionWait(int div){
// 待機状態
    division[div].actionWait();
  }

//--------------------------------------------------------------------//
  void moveDone(int div){
// 移動終了
    division[div].moveDone();
  }

//--------------------------------------------------------------------//
  void actionDone(int div){
// 行動終了
    division[div].actionDone();
  }

//--------------------------------------------------------------------//
  boolean isHide(int div){
// 伏兵判定
    return division[div].hide;
  }

//--------------------------------------------------------------------//
  void appear(int div){
// 伏兵解除
    division[div].appear();
  }

//--------------------------------------------------------------------//
  void ambush(int div){
// 伏兵
    division[div].ambush();
  }

//--------------------------------------------------------------------//
  void Damage(int div,int damage){
// 部隊の戦闘によるダメージ
    division[div].Damage(damage);
  }

//--------------------------------------------------------------------//
  boolean useMoney(int div,int cost){
// 部隊の資金使用
    return division[div].useMoney(cost);
  }

//--------------------------------------------------------------------//
  void Training(int div){
// 部隊訓練
    division[div].Training();
  }

//--------------------------------------------------------------------//
  void eatFood(){
// 兵糧消費
    int i;
    for(i=0;i<divisionNumber;i++){
      division[i].eatFood();
    }
  }

//--------------------------------------------------------------------//
  boolean CheckFormation(int div1,int div2){
// 編成可能の判定
    return (division[div1].weapon==division[div2].weapon);
  }

//--------------------------------------------------------------------//
  int Construct(int div){
// 部隊建設能力
    return division[div].Construct();
  }

//--------------------------------------------------------------------//
  int AttackRange(int div){
// 攻撃射程
    return division[div].weapon.attackRange;
  }

//--------------------------------------------------------------------//
  int soldierNumber(){
// 総兵士数
    int i,soldier=0;

    for(i=0;i<divisionNumber;i++){
      soldier+=division[i].soldierNumber;
    }
    return soldier;
  }

//--------------------------------------------------------------------//
  int generalNumber(){
// 総武将数
    int i,general=0;

    for(i=0;i<divisionNumber;i++){
      general+=division[i].generalNumber;
    }
    return general;
  }

//--------------------------------------------------------------------//
  void drawDivisionLocal(Graphics g,int div,int gxy,int x0,int y0){
// 部隊の描画
    division[div].drawDivisionLocal(g,gxy,x0,y0,color,textColor);
  }

//--------------------------------------------------------------------//
  void drawDivisionGlobal(Graphics g,int div,int gxy,int x0,int y0){
// 全体マップでの部隊の描画
    division[div].drawDivisionGlobal(g,gxy,x0,y0,color,textColor);
  }

//--------------------------------------------------------------------//
  void drawNationList(Graphics g,int x0,int y0){
// 国家リストの描画
    if(divisionNumber>0){
      StringList list=new StringList(g,x0,y0);
      list.setColor(color);
      list.drawString(name);
      list.setColor(textColor);
      list.tabString(NATIONNAME);
      list.space();
      list.drawStringNumber(SOLNUMBER,soldierNumber()
                           ,NATIONDIV*MAXNUMBER);
      list.space();
      list.drawStringNumber(DIVNUMBER,divisionNumber,NATIONDIV);
      list.space();
      list.drawStringNumber(GENERALNUMBER,generalNumber(),NATIONDIV*DIVGENERAL);
    }
  }

//--------------------------------------------------------------------//
  void drawDivisionList(Graphics g,FontMetrics fm,int div,int x0,int y0){
// 部隊リストの描画
    g.setColor(color);
    g.drawString(name,x0,y0);
    g.setColor(textColor);
    x0+=fm.stringWidth(name)+MARGINX;
    division[div].drawDivisionList(g,x0,y0);
  }

//--------------------------------------------------------------------//
  void drawParameter(Graphics g,FontMetrics fm,int div,int x0,int y0,int sy
      	      	    ,Color textColor){
// 部隊情報の表示
    int sx=fm.stringWidth(name)+MARGINX;
    g.setColor(color);
    g.drawString(name,x0,y0);
    g.setColor(textColor);
    division[div].drawParameter(g,fm,x0,y0,sx,sy);
  }

//--------------------------------------------------------------------//
  void drawParameter(Graphics g,FontMetrics fm,int div,int x0,int y0,int sy
      	      	    ,Color backColor,Color textColor){
// 部隊情報の表示
    int i,sx=fm.stringWidth(name)+MARGINX,fx=2*MARGINX,fy;
    g.setColor(backColor);
    for(i=0;i<GENERALLIST.length;i++){
      fx+=fm.stringWidth(GENERALLIST[i])+MARGINX;
    }
    fy=(division[div].generalNumber+8)*sy+MARGINY;
    g.fillRect(x0,y0,fx,fy);
    x0+=MARGINX;
    y0+=sy;
    g.setColor(color);
    g.drawString(name,x0,y0);
    g.setColor(textColor);
    division[div].drawFullParameter(g,fm,x0,y0,sx,sy);
  }
}

//--------------------------------------------------------------------//
// 部隊クラス
class Division implements Parameters,Words,DivisionStatus{
  int id;               // 部隊番号
  String name;          // 部隊名
  int nation;           // 部隊が所属する国家
  int soldierNumber;    // 部隊兵数
  int training;         // 部隊訓練度
  int food;             // 所持兵糧
  int money;            // 所持金
  int generalNumber=0;  // 部隊内の武将数
  int x,y;              // 部隊の位置
  int politics;         // 所属武将の政略の最大値
  int strategy;         // 所属武将の知略の最大値
  int command;          // 所属武将の指揮の最大値
  int strength;         // 所属武将の武力の最大値
  int charisma;         // 所属武将の魅力の最大値
  int attack;           // 部隊の攻撃力
  int defense;          // 部隊の防御力
  int move;             // 部隊の機動力
  int direction;        // 部隊の向いている方向
  boolean hide=false;   // 伏兵スイッチ
  int status=WAIT;      // 部隊の状態
  Weapon weapon;        // 兵種
  General general[]=new General[DIVGENERAL];  // 部隊所属将軍

  Division(int id,String name,int nation,int soldierNumber,int training
      	  ,int food,int money,int x,int y,int direction
      	  ,Weapon weapon){
    this.id=id;
    this.name=name;
    this.nation=nation;
    this.soldierNumber=Math.min(soldierNumber,MAXNUMBER);
    this.training=Math.min(training,MAXPARAMETER);
    this.food=Math.min(food,MAXNUMBER);
    this.money=Math.min(money,MAXNUMBER);
    this.x=x;
    this.y=y;
    this.direction=direction;
    this.weapon=weapon;
    setParameter();
  }

  Division(int id,Division division){
    this(id,division.name,division.nation,division.soldierNumber,division.training
      	,division.food,division.money,division.x,division.y
      	,division.direction,division.weapon);
  }

//--------------------------------------------------------------------//
  void addGeneral(General gen){
// 部隊所属将軍の追加
    if(generalNumber>=DIVGENERAL) return;
    general[generalNumber]=gen;
    generalNumber++;
    setParameter();
  }

//--------------------------------------------------------------------//
  void deleteGeneral(int del){
// 部隊所属将軍の削除
    int i;
    generalNumber--;
    for(i=del;i<generalNumber;i++){
      general[i]=general[i+1];
    }
    general[generalNumber]=null;
  }

//--------------------------------------------------------------------//
  void setParameter(){
// 部隊内武将パラメータの設定
    int i;

    politics=MINPARAMETER;
    strategy=MINPARAMETER;
    command=MINPARAMETER;
    strength=MINPARAMETER;
    charisma=MINPARAMETER;
    for(i=0;i<generalNumber;i++){
      politics=Math.max(general[i].politics,politics);
      strategy=Math.max(general[i].strategy,strategy);
      command=Math.max(general[i].command,command);
      strength=Math.max(general[i].strength,strength);
      charisma=Math.max(general[i].charisma,charisma);
    }
    setDivisionParameter();
  }

//--------------------------------------------------------------------//
  void setDivisionParameter(){
// 部隊パラメータの設定
    attack=(int)(Math.sqrt((double)soldierNumber)*weapon.attack
          *((double)(strength+command)+0.5*training));
    defense=(int)(0.5*weapon.defense*(command+training));
    move=weapon.move+(int)(0.0125*(command+training));
  }

//--------------------------------------------------------------------//
  void moveDivision(int x,int y,int direction){
// 部隊の移動
    this.x=x;
    this.y=y;
    this.direction=direction;
  }

//--------------------------------------------------------------------//
  void setDirection(int direction){
// 部隊の方向転換
    this.direction=direction;
  }

//--------------------------------------------------------------------//
  void actionWait(){
// 待機状態
    status=WAIT;
  }

//--------------------------------------------------------------------//
  void moveDone(){
// 移動終了
    status=MOVED;
  }

//--------------------------------------------------------------------//
  void actionDone(){
// 行動終了
    status=DONE;
  }

//--------------------------------------------------------------------//
  void setStatus(int status){
// 状態設定
    this.status=status;
  }

//--------------------------------------------------------------------//
  void appear(){
// 伏兵解除
    hide=false;
  }

//--------------------------------------------------------------------//
  void ambush(){
// 伏兵
    hide=true;
  }

//--------------------------------------------------------------------//
  void SupplyFood(int supply){
// 兵糧補充
    food=Math.max(Math.min(food+supply,MAXNUMBER),0);
  }

//--------------------------------------------------------------------//
  void SupplyMoney(int supply){
// 所持金補充
    money=Math.max(Math.min(money+supply,MAXNUMBER),0);
  }

//--------------------------------------------------------------------//
  void SupplySoldier(int supply,int training2){
// 兵士補充
    int number2=Math.min(soldierNumber+supply,MAXNUMBER);
    training=(soldierNumber*training+(number2-soldierNumber)*training2)/number2;
    soldierNumber=number2;
    setDivisionParameter();
  }

//--------------------------------------------------------------------//
  int FoodSupplyLimit(){
// 兵糧補充可能量
    return MAXNUMBER-food;
  }

//--------------------------------------------------------------------//
  int MoneySupplyLimit(){
// 資金補充可能量
    return MAXNUMBER-money;
  }

//--------------------------------------------------------------------//
  int SoldierSupplyLimit(){
// 兵士補充可能量
    return MAXNUMBER-soldierNumber;
  }

//--------------------------------------------------------------------//
  boolean useMoney(int cost){
// 部隊の資金使用
    if(money>=cost){
      money-=cost;
      return true;
    }
    else{
      return false;
    }
  }

//--------------------------------------------------------------------//
  void Damage(int damage){
// 部隊の戦闘によるダメージ
    soldierNumber=Math.max(soldierNumber-damage,0);
    setDivisionParameter();
  }

//--------------------------------------------------------------------//
  void Training(){
// 部隊訓練
    int dtraining=Math.max(250*(strength+command)/soldierNumber,1);
    training=Math.min(training+dtraining,MAXPARAMETER);
    setDivisionParameter();
  }

//--------------------------------------------------------------------//
  void eatFood(){
// 兵糧消費
    food=Math.max((int)((double)food-EAT*soldierNumber),0);
    if(food==0){
      soldierNumber=(int)((1.0-ESCAPE)*soldierNumber);
    }
  }

//--------------------------------------------------------------------//
  int Construct(){
// 部隊建設能力
    return politics/5;
  }

//--------------------------------------------------------------------//
  int Bonus(){
// 物資調達ボーナス
    return politics+charisma/2;
  }

//--------------------------------------------------------------------//
  int getSoldier(){
// 兵士補充能力
    return politics+charisma;
  }

//--------------------------------------------------------------------//
  void drawDivisionLocal(Graphics g,int gxy,int x0,int y0
      	      	      	,Color color,Color textColor){
// 部隊の描画
    drawDivision.draw(g,gxy,x0,y0,soldierNumber,direction,hide,color,textColor);
  }

//--------------------------------------------------------------------//
  void drawDivisionGlobal(Graphics g,int gxy,int x0,int y0
      	      	      	 ,Color color,Color textColor){
// 全体マップでの部隊の描画
    g.setColor(color);
    g.fillRect(x0,y0,gxy,gxy);
    g.setColor(textColor);
    g.drawRect(x0,y0,gxy,gxy);
  }

//--------------------------------------------------------------------//
  void drawDivisionList(Graphics g,int x0,int y0){
// 部隊リストの描画
    StringList list=new StringList(g,x0,y0);
    list.drawString(drawName(name));
    list.tabString(DIVNAME);
    list.space();
    list.drawStringNumber(FOODLABEL,food,MAXNUMBER);
    list.space();
    list.drawStringNumber(MONEYLABEL,money,MAXNUMBER);
    list.space();
    list.drawStringNumber(SOLNUMBER,soldierNumber,MAXNUMBER);
    list.space();
    list.drawStringNumber(TRAIN,training,MAXPARAMETER);
    list.space();
    list.drawStrings(WEAPON,weapon.name,WEAPONNAME);
    list.space();
    list.drawStringNumber(GENERALNUMBER,generalNumber,DIVGENERAL);
    list.space();
    list.drawStringNumber(POSITION+" x =",x,COORDMAX);
    list.space();
    list.drawStringNumber("y =",y,COORDMAX);
    list.space();
    list.drawString(DIVSTATUS[status]);
  }

//--------------------------------------------------------------------//
  void drawDivisionExchange(Graphics g,int x0,int y0,int sy){
// 部隊編成の描画
    int i;

    StringList list=new StringList(g,x0,y0);
    list.drawString(drawName(name));
    list.lineFeed(sy);
    list.drawStringNumber(FOODLABEL,food,MAXNUMBER);
    list.lineFeed(sy);
    list.drawStringNumber(MONEYLABEL,money,MAXNUMBER);
    list.lineFeed(sy);
    list.drawStringNumber(SOLNUMBER,soldierNumber,MAXNUMBER);
    list.lineFeed(sy);
    list.drawStringNumber(TRAIN,training,MAXPARAMETER);
    list.lineFeed(sy);
    list.drawStringNumber(GENERALNUMBER,generalNumber,DIVGENERAL);
    for(i=0;i<generalNumber;i++){
      list.lineFeed(sy);
      list.space();
      list.drawString(general[i].name);
    }
  }

//--------------------------------------------------------------------//
  void drawParameter(Graphics g,FontMetrics fm,int x0,int y0,int sx,int sy){
// 部隊情報の表示
    StringList list=new StringList(g,x0,y0);
    drawParameter(list,fm,x0,sx,sy);
  }

//--------------------------------------------------------------------//
  void drawParameter(StringList list,FontMetrics fm,int x0,int sx,int sy){
// 部隊情報の表示
    int sx1,sx2,sx3,x1;

    sx1=fm.stringWidth(FOODLABEL+MAXNUMBER);
    sx2=fm.stringWidth(SOLNUMBER+MAXNUMBER);
    sx3=fm.stringWidth(WEAPON+WEAPONNAME);
    x1=x0+MARGINX+Math.max(Math.max(sx1,sx2),sx3);

    list.setPosition(x0+sx+MARGINX);
    list.drawString(drawName(name));
    if(hide){
      list.tabString(drawName(name));
      list.space();
      list.drawString(AMBUSHD);
    }
    list.lineFeed(sy);
    list.drawStringNumber(FOODLABEL,food,MAXNUMBER);
    list.setPosition(x1);
    list.drawStringNumber(MONEYLABEL,money,MAXNUMBER);
    list.lineFeed(sy);
    list.drawStringNumber(SOLNUMBER,soldierNumber,MAXNUMBER);
    list.setPosition(x1);
    list.drawStringNumber(TRAIN,training,MAXPARAMETER);
    list.lineFeed(sy);
    list.drawStrings(WEAPON,weapon.name,WEAPONNAME);
    list.setPosition(x1);
    list.drawStringNumber(MOVEP,move,MAXPARAMETER);
    list.lineFeed(sy);
    list.drawStringNumber(GENERALNUMBER,generalNumber,DIVGENERAL);
    list.lineFeed(sy);
  }

//--------------------------------------------------------------------//
  void drawFullParameter(Graphics g,FontMetrics fm,int x0,int y0,int sx,int sy){
// 部隊情報の表示
    int i,sx1,sx2,sx3,x1;

    StringList list=new StringList(g,x0,y0);
    drawParameter(list,fm,x0,sx,sy);

    for(i=0;i<GENERALLIST.length;i++){
      list.space();
      list.drawString(GENERALLIST[i]);
      list.tabString(GENERALLIST[i]);
    }
    for(i=0;i<generalNumber;i++){
      list.lineFeed(sy);
      list.space();
      general[i].drawParameter(list);
    }
    list.lineFeed(sy);
    list.drawStringNumber(POSITION+" x =",x,COORDMAX);
    list.space();
    list.drawStringNumber("y =",y,COORDMAX);
    list.lineFeed(sy);
    list.drawString(DIVSTATUS[status]);
  }

//--------------------------------------------------------------------//
  private String drawName(String name){
// 表示部隊名
    if(name.equals("null")){
      return ARMYNAME[0]+(id+1)+ARMYNAME[1];
    }
    else{
      return name;
    }
  }
}

//--------------------------------------------------------------------//
// 兵種クラス
class Weapon{
  int id;           // 兵種番号
  String name;      // 兵種名
  int move;         // 基本移動力
  int attack;       // 基本攻撃力
  int attackRange;  // 攻撃射程
  boolean counter;  // 攻撃に対し反撃を喰らうか
  int defense;      // 基本防御力
  int cost;         // コスト

  Weapon(int id,String name,int move,int attack,int attackRange,boolean counter
      	,int defense,int cost){
    this.id=id;
    this.name=name;
    this.move=move;
    this.attack=attack;
    this.attackRange=attackRange;
    this.counter=counter;
    this.defense=defense;
    this.cost=cost;
  }
}

//--------------------------------------------------------------------//
// 武将クラス
class General implements Parameters,Words{
  int id;              // 武将番号
  String name;         // 武将名
  int nation;          // 武将が所属する国家
  int division;        // 武将が所属する部隊
  int politics;        // 武将の政略
  int strategy;        // 武将の知略
  int command;         // 武将の指揮
  int strength;        // 武将の武力
  int charisma;        // 武将の魅力
  boolean king=false;  // 王フラッグ

  General(int id,String name,int politics,int strategy,int command
      	 ,int strength,int charisma){
    this.id=id;
    this.name=name;
    this.politics=Math.min(politics,MAXPARAMETER);
    this.strategy=Math.min(strategy,MAXPARAMETER);
    this.command=Math.min(command,MAXPARAMETER);
    this.strength=Math.min(strength,MAXPARAMETER);
    this.charisma=Math.min(charisma,MAXPARAMETER);
  }

//--------------------------------------------------------------------//
  void setDivision(int nation,int division){
// 所属部隊の設定
    this.nation=nation;
    this.division=division;
  }

//--------------------------------------------------------------------//
  void setKing(){
// 王の設定
    king=true;
  }

//--------------------------------------------------------------------//
  void drawParameter(StringList list){
// 武将情報の表示
    list.drawString(name);
    list.tabString(GENERALLIST[0]);
    list.space();
    list.drawNumber(politics,GENERALLIST[1]);
    list.space();
    list.drawNumber(strategy,GENERALLIST[2]);
    list.space();
    list.drawNumber(command,GENERALLIST[3]);
    list.space();
    list.drawNumber(strength,GENERALLIST[4]);
    list.space();
    list.drawNumber(charisma,GENERALLIST[5]);
  }
}

//--------------------------------------------------------------------//
// 部隊描画クラス
class drawDivision implements DivisionStatus{
  private static final int POINT=8;     // 描画形状の頂点数
  private static final double NORTHX[]={0.0,0.25,0.25,0.75,0.75,1.0,1.0,0.0};
  private static final double NORTHY[]={0.25,0.25,0.0,0.0,0.25,0.25,1.0,1.0};
  private static final double EASTX[]={0.75,0.75,1.0,1.0,0.75,0.75,0.0,0.0};
  private static final double EASTY[]={0.0,0.25,0.25,0.75,0.75,1.0,1.0,0.0};
  private static final double SOUTHX[]={0.0,0.25,0.25,0.75,0.75,1.0,1.0,0.0};
  private static final double SOUTHY[]={0.75,0.75,1.0,1.0,0.75,0.75,0.0,0.0};
  private static final double WESTX[]={0.25,0.25,0.0,0.0,0.25,0.25,1.0,1.0};
  private static final double WESTY[]={0.0,0.25,0.25,0.75,0.75,1.0,1.0,0.0};

//--------------------------------------------------------------------//
  public static void draw(Graphics g,int gxy,int x0,int y0
      	      	      	 ,int soldierNumber,int direction,boolean ambush
      	      	      	 ,Color color,Color textColor){
// 部隊の描画
    FontMetrics fm=g.getFontMetrics();
    int i,sx,sy;
    int polygonX[]=new int[POINT];
    int polygonY[]=new int[POINT];

    switch(direction){
      case NORTH:
      	for(i=0;i<POINT;i++){
      	  polygonX[i]=x0+(int)(gxy*NORTHX[i]);
      	  polygonY[i]=y0+(int)(gxy*NORTHY[i]);
      	}
      	break;
      case EAST:
      	for(i=0;i<POINT;i++){
      	  polygonX[i]=x0+(int)(gxy*EASTX[i]);
      	  polygonY[i]=y0+(int)(gxy*EASTY[i]);
      	}
      	break;
      case SOUTH:
      	for(i=0;i<POINT;i++){
      	  polygonX[i]=x0+(int)(gxy*SOUTHX[i]);
      	  polygonY[i]=y0+(int)(gxy*SOUTHY[i]);
      	}
      	break;
      case WEST:
      	for(i=0;i<POINT;i++){
      	  polygonX[i]=x0+(int)(gxy*WESTX[i]);
      	  polygonY[i]=y0+(int)(gxy*WESTY[i]);
      	}
      	break;
    }
    sx=(gxy-fm.stringWidth(""+soldierNumber))/2;
    sy=(gxy+fm.getHeight())/2;
    if(ambush)
      color=new Color(color.getRed(),color.getGreen(),color.getBlue(),128);
    g.setColor(color);
    g.fillPolygon(polygonX,polygonY,POINT);
    g.setColor(textColor);
    g.drawPolygon(polygonX,polygonY,POINT);
    g.drawString(""+soldierNumber,x0+sx,y0+sy);
  }
}

//--------------------------------------------------------------------//
// 文字列リストクラス
class StringList implements Parameters{
  private Graphics g;
  private FontMetrics fm;
  private int x0,x1,y0,y1;

  StringList(Graphics g,int x0,int y0){
    this.g=g;
    fm=g.getFontMetrics();
    this.x0=x0;
    this.y0=y0;
    x1=x0;
    y1=y0;
  }

//--------------------------------------------------------------------//
  void setColor(Color color){
// 色の変更
    g.setColor(color);
  }

//--------------------------------------------------------------------//
  void drawString(String string){
// 文字の描画
    g.drawString(string,x1,y1);
  }

//--------------------------------------------------------------------//
  void drawString(String string,String stab){
// 文字の描画
    tabString(stab);
    g.drawString(string,x1-fm.stringWidth(string),y1);
  }

//--------------------------------------------------------------------//
  void tabString(String string){
// 表示位置移動
    x1+=fm.stringWidth(string);
  }

//--------------------------------------------------------------------//
  void space(){
// 表示位置移動
    x1+=MARGINX;
  }

//--------------------------------------------------------------------//
  void drawNumber(int number,int maxnumber){
// 数字の描画
    String string=""+number;
    x1+=fm.stringWidth(""+maxnumber);
    g.drawString(string,x1-fm.stringWidth(string),y1);
  }

//--------------------------------------------------------------------//
  void drawNumber(int number,String length){
// 数字の描画
    String string=""+number;
    x1+=fm.stringWidth(length);
    g.drawString(string,x1-fm.stringWidth(string),y1);
  }

//--------------------------------------------------------------------//
  void drawStringNumber(String string,int number,int maxnumber){
// 文字・数字項目の描画
    drawString(string);
    tabString(string);
    drawNumber(number,maxnumber);
  }

//--------------------------------------------------------------------//
  void drawStrings(String string1,String string2,String stab){
// 文字項目の描画
    drawString(string1);
    tabString(string1);
    drawString(string2,stab);
  }

//--------------------------------------------------------------------//
  void setPosition(int x){
// 位置合わせ
    x1=x;
  }

//--------------------------------------------------------------------//
  void setPosition(int x,int y){
// 位置合わせ
    x1=x;
    y1=y;
  }

//--------------------------------------------------------------------//
  void lineFeed(int height){
// 改行
    x1=x0;
    y1+=height;
  }
}

//--------------------------------------------------------------------//
// ボタンクラス
class ControlButton implements Parameters{
  private String label;           // ボタンラベル
  private int x0,y0;              // 基準位置
  private int x,y;                // ボタン大きさ
  private int tx,ty;              // 文字位置
  private boolean pressed=false;  // ボタン押しフラッグ

  ControlButton(FontMetrics fm,String label,int x0,int y0){
    this.label=label;
    this.x0=x0;
    this.y0=y0;
    x=fm.stringWidth(label)+MARGINX;
    y=fm.getHeight()+MARGINY;
    tx=x0+MARGINX/2;
    ty=y0+fm.getHeight()+MARGINY/2;
  }

  ControlButton(FontMetrics fm,String label,int x0,int y0,int x,int y){
    this.label=label;
    this.x0=x0;
    this.y0=y0;
    this.x=x;
    this.y=y;
    tx=x0+(x-fm.stringWidth(label))/2;
    ty=y0+(y+fm.getHeight())/2;
  }

//--------------------------------------------------------------------//
  void draw(Graphics g,Color backColor,Color textColor){
// ボタン描画

    if(pressed){
      g.setColor(textColor);
      g.fillRect(x0,y0,x,y);
      g.setColor(backColor);
    }
    else{
      g.setColor(backColor);
      g.fillRect(x0,y0,x,y);
      g.setColor(textColor);
      g.drawRect(x0,y0,x,y);
    }
    g.drawString(label,tx,ty);
  }

//--------------------------------------------------------------------//
  void Press(){
// ボタン押し
    pressed=true;
  }

//--------------------------------------------------------------------//
  void Release(){
// ボタン離し
    pressed=false;
  }

//--------------------------------------------------------------------//
  boolean press(int px,int py){
// ボタン押し判定
    pressed=false;
    if(x0<=px && px<=x0+x){
      if(y0<=py && py<=y0+y){
      	pressed=true;
      }
    }
    return pressed;
  }
}

//--------------------------------------------------------------------//
// イメージクラス
class ImageData extends Panel implements Parameters{
  private static final int NMAX=100;    // テンプレート大きさ・部品数の上限

  private int nx,ny,number;             // テンプレート内の部品数
  Image partImage[]=new Image[NMAX];    // 部品イメージ

  ImageData(Image image,int partSize){
    nx=image.getWidth(this)/partSize;
    ny=image.getHeight(this)/partSize;
    number=Math.min(nx*ny,NMAX);
    makePartImage(image,partSize);
    BlackToClear(CURSOR);
    halfClear(SELECTEDAREA);
  }

//--------------------------------------------------------------------//
  void makePartImage(Image image,int partSize){
// イメージ部品取り出し
    int i,x0,y0;

    for(i=0;i<number;i++){
      x0=(i%nx)*partSize;
      y0=(i/nx)*partSize;
      CropImageFilter cif=new CropImageFilter(x0,y0,partSize,partSize);
      partImage[i]=createImage
      	      	  (new FilteredImageSource(image.getSource(),cif));
    }
  }

//--------------------------------------------------------------------//
  void BlackToClear(int part){
// 黒い部分を透明にするフィルタ
    ImageFilter cf=new ClearFilter(0,0,0);
    partImage[part]=createImage(new FilteredImageSource
      	      	    (partImage[part].getSource(),cf));
  }

//--------------------------------------------------------------------//
  void halfClear(int part){
// 半透明にするフィルタ
    ImageFilter hcf=new halfClearFilter(0,0,0);
    partImage[part]=createImage(new FilteredImageSource
      	      	    (partImage[part].getSource(),hcf));
  }
}

//--------------------------------------------------------------------//
// 指定した色を透明にするフィルタ
class ClearFilter extends RGBImageFilter{
  private int rgbColor;

  ClearFilter(int r,int g,int b){
    rgbColor=0xFF000000|(r<<16)|(g<<8)|b;
    canFilterIndexColorModel=true;
  }

//--------------------------------------------------------------------//
  public int filterRGB(int x,int y,int rgb){
// フィルタ部分
    if(rgb==rgbColor) rgb=0;
    return rgb;
  }
}

//--------------------------------------------------------------------//
// 半透明にするフィルタ
class halfClearFilter extends RGBImageFilter{

  halfClearFilter(int r,int g,int b){
    canFilterIndexColorModel=true;
  }

//--------------------------------------------------------------------//
  public int filterRGB(int x,int y,int rgb){
// フィルタ部分
    return 0x80FFFFFF&rgb;
  }
}