//--------------------------------------------------------------------//
//   戦略シミュレーション ver.0.0				      //
//					  2002/01/04 作成  樋口和宏   //
//--------------------------------------------------------------------//
// クラス一覧
//  class WarSimulation       メイン
//  class fieldPanel          フィールド表示部分
//  class ControlButton       コントロールボタンクラス
//  class DataCore            データ管理
//  class Formation           部隊編成クラス
//  class Supply              部隊補給クラス
//  class ImageData           イメージクラス
//  class FieldParts          フィールド部品クラス
//  class Castle              城クラス
//  class Grid                フィールドデータクラス
//  class Nation              国家クラス
//  class Division            部隊クラス
//  class Weapon              兵種クラス
//  class General             武将クラス
//  class FileFormatException ファイル書式例外処理
//  class ClearFilter         指定した色を透明にするフィルタ
//  class halfClearFilter     半透明にするフィルタ
//  class drawDivision        部隊描画クラス
//--------------------------------------------------------------------//

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

//--------------------------------------------------------------------//
// メイン
public class WarSimulation extends Applet{
  fieldPanel fpanel;
  Image template=null;
  MediaTracker mt=new MediaTracker(this);

//--------------------------------------------------------------------//
  public void init(){
// データファイル名
    String fname,iname,size;
    int imageSize=40;

    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);
    setLayout(new BorderLayout());
    getTemplateImage(iname);
    try{
      mt.waitForAll();
      fpanel=new fieldPanel(base,fname,template,imageSize);
      add("Center",fpanel);
    }
    catch(InterruptedException e){}
  }

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

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

//--------------------------------------------------------------------//
// フィールド表示部分
class fieldPanel extends Panel
  implements Runnable,MouseListener,MouseMotionListener,KeyListener{
    static final int LOCALMAP=0;     // 画面モード
    static final int GLOBALMAP=1;
    static final int DIVISIONLIST=2;
    static final int NATIONLIST=3;

    static final int NATIONSELECT=0; // 状態スイッチ
    static final int PLAYERTURN=1;
    static final int SELECT=2;
    static final int MOVE=3;
    static final int ATTACK=4;
    static final int DIRECTION=5;
    static final int FORMATION=6;
    static final int EXCHANGE=7;
    static final int SUPPLY=8;
    static final int CONSTRUCT=9;
    static final int TRAINING=10;
    static final int TURNEND=11;
    static final int ENEMYTURN=12;

    static final int FOOD=0;         // 編成
    static final int MONEY=1;
    static final int SOLDIER=2;
    static final int DELTA=100;
    static final int MARGIN=5;       // マージン

    DataCore dc;
    Thread viewThread=null;
    String errorMessage;             // エラーメッセージ
    int fx,fy;                       // 地図表示サイズ・位置
    int sy;                          // 文字表示高さ
    int indexViewRange;
    private Image bgImage;           // ダブルバッファリング用イメージ
    private Graphics bg;
    int mapPoint=DataCore.NONE;      // 地図上の位置
    int currentIndex=0;
    int mousex=0,mousey=0;           // マウス位置
    int mapmode=LOCALMAP;            // 画面モード
    int status=NATIONSELECT;         // 状態スイッチ
    int waitTime=200,waitTime2=10,waitTime3=200; // 表示待ち時間
    int attackAction=10;             // 攻撃行動グラフィック表示回数
    Color backColor=Color.black,textColor=Color.white;  // 背景色・文字色
    int fontSize=12;                 // 文字フォントサイズ
    int turn=0;                      // ターン数
    int game=DataCore.GAME;
    boolean running=false;
    ControlButton move,attack,direction,formation,train,end,done; // ボタン
    ControlButton supply,construct,occupy;
    ControlButton constructFood,constructMoney,constructClass;
    ControlButton globalMap,divList,nationList,turnEnd;
    ControlButton yes,no;
    ControlButton decide,cancel;

//--------------------------------------------------------------------//
  fieldPanel(URL base,String name,Image image,int imageSize){
    getData(base,name,image,imageSize);
    dc.setViewPoint(0);
    setBackground(backColor);
    addMouseListener(this);
    addMouseMotionListener(this);
    addKeyListener(this);
  }

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

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

//--------------------------------------------------------------------//
  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!=DataCore.NONE){
      for(i=dc.moving;i>0;i--){
      	dc.moveDraw(i-1);
      	repaint();
      	try{
      	  viewThread.sleep(waitTime);
      	}
      	catch(InterruptedException e){
      	}
      }
      dc.setDivViewPoint(dc.currentNation,dc.currentDivision);
      dc.moveDone();
      repaint();
    }
  }

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

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

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

    if(dc.currentDivision!=DataCore.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;
      if(ndiv==0) EndOfDivision=true;
      else        EndOfDivision=false;
      while(!EndOfDivision){
      	dc.findAttackDivision(dc.currentNation,div);
      	mapPoint=dc.moveTarget;                                 // 移動
      	dc.setMoveDivision(mapPoint);
      	dc.clearMoveDistance();
      	moveRun();
      	try{
      	  viewThread.sleep(waitTime3);
      	}
      	catch(InterruptedException e){
      	}
      	if(dc.attackedDivision!=DataCore.NONE){                 // 攻撃
      	  mapPoint=dc.divisionPoint(dc.attackedNation
      	      	      	      	   ,dc.attackedDivision);
      	  dc.setAttackDivision(mapPoint,dc.attackedNation
      	      	      	      ,dc.attackedDivision);
      	  dc.clearAttackDistance();
      	  attackRun();
      	  try{
      	    viewThread.sleep(waitTime3);
      	  }
      	  catch(InterruptedException e){
      	  }
      	}
      	if(dc.game!=DataCore.GAME){                             // ゲームオーバー
      	  EnemyTurn=false;
      	  EndOfDivision=true;
      	}
      	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(game==DataCore.GAME){
      dc.setCurrentDivision(dc.playerNation,DataCore.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==TURNEND){
      actionTurnEnd();
    }
    else{
      switch(mapmode){
      	case LOCALMAP:
      	  newpt=dc.getMapPointLocal(mousex,mousey);
      	  if(newpt!=DataCore.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(globalMap.press(mousex,mousey)){
      	      mapmode=GLOBALMAP;
      	    }
      	    else if(divList.press(mousex,mousey)){
      	      mapmode=DIVISIONLIST;
      	    }
      	    else if(nationList.press(mousex,mousey)){
      	      mapmode=NATIONLIST;
      	    }
      	    else if(turnEnd.press(mousex,mousey)){
      	      status=TURNEND;
      	    }
      	    globalMap.Release();
      	    divList.Release();
      	    nationList.Release();
      	    turnEnd.Release();
      	  }
      	  break;
      	case GLOBALMAP:
      	  actionGlobalMap();
      	  break;
      	case DIVISIONLIST:
      	  actionDivisionList();
      	  break;
      	case NATIONLIST:
      	  actionNationList();
      	  break;
      }
    }
    repaint();
    e.consume();
  }

//--------------------------------------------------------------------//
  void actionNationSelect(){
// 国家選択画面での行動
    if(currentIndex<dc.nationNumber){
      dc.setPlayerNation(currentIndex);
      dc.allWait();
      turn++;
      status=ENEMYTURN;
      mapmode=LOCALMAP;
      start();
    }
  }

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

    if(decide.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.formationSet(mapPoint);
    }
    else if(cancel.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.formationCancel();
    }
    else{
      if(mousex<fx/2){
      	div=0;
      	indexMax=5+dc.formation.formDivision1.generalNumber;
      }
      else{
      	div=1;
      	indexMax=5+dc.formation.formDivision2.generalNumber;
      }
      if(currentIndex==FOOD){                              // 兵糧編成
      	dc.foodExchange(div,DELTA);
      }
      else if(currentIndex==MONEY){                        // 所持金編成
      	dc.moneyExchange(div,DELTA);
      }
      else if(currentIndex==SOLDIER){                      // 兵数編成
      	dc.numberExchange(div,DELTA);
      }
      else if(4<currentIndex && currentIndex<indexMax){    // 武将編成
      	dc.generalExchange(div,currentIndex-5);
      }
    }
  }

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

    if(decide.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.supplySet(mapPoint);
    }
    else if(cancel.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.supplyCancel();
    }
    else{
      if(mousex<fx/2){
      	div=0;
      }
      else{
      	div=1;
      }
      if(currentIndex==FOOD){                               // 兵糧編成
      	dc.foodSupply(div,DELTA);
      }
      else if(currentIndex==MONEY){                         // 所持金編成
      	dc.moneySupply(div,DELTA);
      }
      else if(currentIndex==SOLDIER && div==1){             // 募兵
      	status=PLAYERTURN;
      	dc.soldierSupply(mapPoint);
      }
    }
  }

//--------------------------------------------------------------------//
  void actionConstruct(){
// 建設画面での行動
    if(constructFood.press(mousex,mousey)){
      dc.constructFoodProduct(mapPoint);
    }
    else if(constructMoney.press(mousex,mousey)){
      dc.constructMoneyProduct(mapPoint);
    }
    else if(constructClass.press(mousex,mousey)){
      dc.constructCastleClass(mapPoint);
    }
    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.setAttackDistance(mapPoint);
      dc.setFormationPlace(mapPoint);
      status=SELECT;
      setDivisionControlPanel(bg);
    }
  }

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

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

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

    dc.setDirection(mapPoint);
    status=PLAYERTURN;
    repaint();
  }

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

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

//--------------------------------------------------------------------//
  void actionDivisionList(){
// 部隊リストでの行動
    if(currentIndex<dc.nation[dc.currentNation].divisionNumber){
      dc.setDivViewPoint(dc.currentNation,currentIndex);
      mapmode=LOCALMAP;
    }
  }

//--------------------------------------------------------------------//
  void actionNationList(){
// 国家リストでの行動
    if(currentIndex<dc.nationNumber){
      dc.setDivViewPoint(currentIndex,0);
      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();
      switch(dc.nation[nati].division[div].status){
      	case Division.WAIT:
      	  mouseReleasedWait();
      	  break;
      	case Division.MOVED:
      	  mouseReleasedMoved();
      	  break;
      	case Division.DONE:
      	  status=PLAYERTURN;
      	  break;
      }
      repaint();
      e.consume();
    }
  }

//--------------------------------------------------------------------//
  void mouseReleasedWait(){
// 待機状態でのマウスリリースの反応
    if(move.press(mousex,mousey)){
      status=MOVE;
    }
    else if(attack.press(mousex,mousey)){
      status=ATTACK;
    }
    else if(direction.press(mousex,mousey)){
      status=DIRECTION;
    }
    else if(formation.press(mousex,mousey)){
      status=FORMATION;
    }
    else if(train.press(mousex,mousey)){
      status=TRAINING;
      start();
    }
    else if(end.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.actionDone();
    }
    else if(dc.gridNation(mapPoint)==dc.playerNation){
      if(supply.press(mousex,mousey)){
      	status=SUPPLY;
      	dc.setSupply(mapPoint);
      	setDecidePanel(bg);
      }
      else if(construct.press(mousex,mousey)){
      	status=CONSTRUCT;
      }
      else{
      	status=PLAYERTURN;
      }
    }
    else if(!dc.grid[mapPoint].castle){
      status=PLAYERTURN;
    }
    else if(occupy.press(mousex,mousey)){
      dc.occupyCastle(mapPoint);
      status=PLAYERTURN;
    }
    else{
      status=PLAYERTURN;
    }
  }

//--------------------------------------------------------------------//
  void mouseReleasedMoved(){
// 移動終了状態でのマウスリリースの反応
    if(attack.press(mousex,mousey)){
      status=ATTACK;
    }
    else if(direction.press(mousex,mousey)){
      status=DIRECTION;
    }
    else if(formation.press(mousex,mousey)){
      status=FORMATION;
    }
    else if(train.press(mousex,mousey)){
      status=TRAINING;
      start();
    }
    else if(end.press(mousex,mousey)){
      status=PLAYERTURN;
      dc.actionDone();
    }
    else if(dc.gridNation(mapPoint)==dc.playerNation){
      if(supply.press(mousex,mousey)){
      	status=SUPPLY;
      	dc.setSupply(mapPoint);
      	setDecidePanel(bg);
      }
      else if(construct.press(mousex,mousey)){
      	status=CONSTRUCT;
      }
      else{
      	status=PLAYERTURN;
      }
    }
    else if(!dc.grid[mapPoint].castle){
      status=PLAYERTURN;
    }
    else if(occupy.press(mousex,mousey)){
      dc.occupyCastle(mapPoint);
      status=PLAYERTURN;
    }
    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();
      switch(dc.nation[nati].division[div].status){
      	case Division.WAIT:
      	  mouseDraggedWait();
      	  break;
      	case Division.MOVED:
      	  mouseDraggedMoved();
      	  break;
      	case Division.DONE:
      	  break;
      }
      repaint();
      e.consume();
    }
  }

//--------------------------------------------------------------------//
  void mouseDraggedWait(){
// 待機状態でのマウスドラッグの反応
    move.Release();
    attack.Release();
    direction.Release();
    formation.Release();
    train.Release();
    end.Release();
    if(move.press(mousex,mousey));
    else if(attack.press(mousex,mousey));
    else if(direction.press(mousex,mousey));
    else if(formation.press(mousex,mousey));
    else if(train.press(mousex,mousey));
    else if(end.press(mousex,mousey));
    if(dc.gridNation(mapPoint)==dc.playerNation){
      supply.Release();
      construct.Release();
      if(supply.press(mousex,mousey));
      else if(construct.press(mousex,mousey));
    }
    else if(dc.grid[mapPoint].castle){
      occupy.Release();
      if(occupy.press(mousex,mousey));
    }
  }

//--------------------------------------------------------------------//
  void mouseDraggedMoved(){
// 移動終了状態でのマウスドラッグの反応
    attack.Release();
    direction.Release();
    formation.Release();
    train.Release();
    end.Release();
    if(attack.press(mousex,mousey));
    else if(direction.press(mousex,mousey));
    else if(formation.press(mousex,mousey));
    else if(train.press(mousex,mousey));
    else if(end.press(mousex,mousey));
    if(dc.gridNation(mapPoint)==dc.playerNation){
      supply.Release();
      construct.Release();
      if(supply.press(mousex,mousey));
      else if(construct.press(mousex,mousey));
    }
    else if(dc.grid[mapPoint].castle){
      occupy.Release();
      if(occupy.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-2;
      	break;
      case SUPPLY:
      	currentIndex=mousey/sy-2;
      	break;
      case CONSTRUCT:
      	mouseMovedConstruct();
      	break;
      case TURNEND:
      	break;
    }
    repaint();
    e.consume();
  }

//--------------------------------------------------------------------//
  void mouseMovedConstruct(){
// 建設状態でのマウス移動の反応
    constructFood.Release();
    constructMoney.Release();
    constructClass.Release();
    if(constructFood.press(mousex,mousey));
    else if(constructMoney.press(mousex,mousey));
    else if(constructClass.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;
      	repaint();
      	break;
      case KeyEvent.VK_N:
      	mapmode=NATIONLIST;
      	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(Graphics g){
// 部隊コントロールパネル設定
    int i,nati,div,sx,x0,y0,cx;
    int cy[]=new int[8];

    if(mousex>=dc.viewSize || mousey>=dc.viewSize) return;
    FontMetrics fm=g.getFontMetrics();
    sx=fm.stringWidth("移動")+MARGIN;
    nati=dc.grid[mapPoint].nation;
    div=dc.grid[mapPoint].division;
    x0=dc.gridSize*(dc.nation[nati].division[div].dx-dc.viewx
      	      	   +DataCore.GHALF);
    y0=dc.gridSize*(dc.nation[nati].division[div].dy-dc.viewy
      	      	   +DataCore.GHALF);
    if(x0<(int)(0.6*dc.viewSize)){
      cx=x0+dc.gridSize+MARGIN;
    }
    else{
      cx=x0-sx-MARGIN;
    }
    if(y0<(int)(0.6*dc.viewSize)){
      cy[0]=y0+2;
      for(i=1;i<8;i++){
      	cy[i]=cy[i-1]+sy;
      }
    }
    else{
      cy[7]=y0+dc.gridSize-sy-2;
      for(i=6;i>=0;i--){
      	cy[i]=cy[i+1]-sy;
      }
    }
    move=new ControlButton("移動",cx,cy[0],sx,sy);
    attack=new ControlButton("攻撃",cx,cy[1],sx,sy);
    direction=new ControlButton("方向",cx,cy[2],sx,sy);
    formation=new ControlButton("編成",cx,cy[3],sx,sy);
    train=new ControlButton("訓練",cx,cy[4],sx,sy);
    if(dc.gridNation(mapPoint)==dc.playerNation){
      supply=new ControlButton("補給",cx,cy[5],sx,sy);
      construct=new ControlButton("建設",cx,cy[6],sx,sy);
      constructFood=new ControlButton("農業",cx,cy[0],sx,sy);
      constructMoney=new ControlButton("商業",cx,cy[1],sx,sy);
      constructClass=new ControlButton("城郭",cx,cy[2],sx,sy);
      end=new ControlButton("終了",cx,cy[7],sx,sy);
    }
    else if(dc.grid[mapPoint].castle){
      occupy=new ControlButton("占領",cx,cy[5],sx,sy);
      end=new ControlButton("終了",cx,cy[6],sx,sy);
    }
    else{
      end=new ControlButton("終了",cx,cy[5],sx,sy);
    }
    done=new ControlButton("済",cx,cy[2],sx,sy);
  }

//--------------------------------------------------------------------//
  void setControlPanel(Graphics g){
// コントロールパネル設定
    int sx1,sx2,sx3,sx4,x0,y0;

    FontMetrics fm=g.getFontMetrics();
    sx1=fm.stringWidth("全体マップ")+MARGIN;
    sx2=fm.stringWidth("部隊一覧")+MARGIN;
    sx3=fm.stringWidth("国家一覧")+MARGIN;
    sx4=fm.stringWidth("ターン終了")+MARGIN;
    x0=dc.viewSize+MARGIN;
    y0=fy-2*sy-MARGIN;
    globalMap=new ControlButton("全体マップ",x0,y0,sx1,sy);
    divList=new ControlButton("部隊一覧",x0+sx1,y0,sx2,sy);
    nationList=new ControlButton("国家一覧",x0+sx1+sx2,y0,sx3,sy);
    turnEnd=new ControlButton("ターン終了",x0,y0+sy,sx4,sy);
    x0=fx/4-sx2/2;
    y0=(fy-sy)/2;
    yes=new ControlButton("はい",x0,y0,sx2,sy);
    no=new ControlButton("いいえ",x0+fx/2,y0,sx2,sy);
  }

//--------------------------------------------------------------------//
  void setDecidePanel(Graphics g){
// 決定ボタンパネル設定
    int sx,x0,x1,y0;

    FontMetrics fm=g.getFontMetrics();
    sx=fm.stringWidth("決定")+MARGIN;
    x0=fx/4-sx/2;
    x1=x0+fx/2;
    y0=fy-sy-MARGIN;
    decide=new ControlButton("決定",x0,y0,sx,sy);
    cancel=new ControlButton("取消",x1,y0,sx,sy);
  }

//--------------------------------------------------------------------//
  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(bg);
      drawScreen(bg);
      g.drawImage(bgImage,0,0,this);
    }
    else if(errorMessage!=null){
      drawError(g,errorMessage);
    }
  }

//--------------------------------------------------------------------//
  void setScreen(Graphics g){
// 画面設定
    Font font=new Font("Serif",Font.PLAIN,fontSize);
    g.setFont(font);
    fx=getSize().width;
    fy=getSize().height;
    bgImage=createImage(fx,fy);
    bg=bgImage.getGraphics();
    bg.setFont(font);
    FontMetrics fm=bg.getFontMetrics();
    sy=fm.getHeight()+MARGIN;
    indexViewRange=fy/sy;
  }

//--------------------------------------------------------------------//
  void drawScreen(Graphics g){
// 画面描画
    switch(game){
      case DataCore.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 DataCore.GAMEOVER:
      	drawError(g,"Game Over");
      	break;
      case DataCore.GAMEWIN:
      	drawError(g,"You Win!");
      	break;
    }
  }

//--------------------------------------------------------------------//
  void drawLocalMap(Graphics g){
// マップ描画
    switch(status){
      default:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	drawCursorLocal(g);
      	if(mapPoint!=DataCore.NONE)
      	  dc.drawStatus(g,mapPoint,dc.viewSize+MARGIN,sy,fx-dc.viewSize,fy,sy);
      	drawControlPanel(g);
      	drawTurn(g);
      	break;
      case NATIONSELECT:
      	drawNationList(g);
      	g.setColor(textColor);
      	g.drawString("プレイヤーの国家を選んで下さい",MARGIN,fy-MARGIN);
      	break;
      case SELECT:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	drawDivisionControlPanel(g);
      	if(mapPoint!=DataCore.NONE)
      	  dc.drawStatus(g,mapPoint,dc.viewSize+MARGIN,sy,fx-dc.viewSize,fy,sy);
      	drawControlPanel(g);
      	drawTurn(g);
      	break;
      case MOVE:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	dc.drawMoveDistance(g);
      	drawCursorLocal(g);
      	if(mapPoint!=DataCore.NONE)
      	  dc.drawStatus(g,mapPoint,dc.viewSize+MARGIN,sy,fx-dc.viewSize,fy,sy);
      	drawControlPanel(g);
      	drawTurn(g);
      	break;
      case ATTACK:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	dc.drawAttackDistance(g);
      	drawCursorLocal(g);
      	if(mapPoint!=DataCore.NONE)
      	  dc.drawStatus(g,mapPoint,dc.viewSize+MARGIN,sy,fx-dc.viewSize,fy,sy);
      	drawControlPanel(g);
      	drawTurn(g);
      	break;
      case DIRECTION:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	drawCursorLocal(g);
      	if(mapPoint!=DataCore.NONE)
      	  dc.drawStatus(g,mapPoint,dc.viewSize+MARGIN,sy,fx-dc.viewSize,fy,sy);
      	drawControlPanel(g);
      	g.setColor(textColor);
      	g.drawString("方向を指定して下さい",dc.viewSize+MARGIN,sy);
      	break;
      case FORMATION:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	dc.drawFormationPlace(g);
      	drawCursorLocal(g);
      	if(mapPoint!=DataCore.NONE)
      	  dc.drawStatus(g,mapPoint,dc.viewSize+MARGIN,sy,fx-dc.viewSize,fy,sy);
      	drawControlPanel(g);
      	drawTurn(g);
      	break;
      case EXCHANGE:
      	drawDivisionExchange(g,MARGIN,sy,fx/2,sy);
      	break;
      case SUPPLY:
      	drawSupply(g,MARGIN,sy,fx/2,sy);
      	break;
      case CONSTRUCT:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	drawConstructPanel(g);
      	if(mapPoint!=DataCore.NONE)
      	  dc.drawStatus(g,mapPoint,dc.viewSize+MARGIN,sy,fx-dc.viewSize,fy,sy);
      	drawControlPanel(g);
      	drawTurn(g);
      	break;
      case TURNEND:
      	dc.drawLocalMap(g);
      	dc.drawDivisionLocal(g,textColor);
      	drawYesNoButton(g);
      	g.setColor(textColor);
      	g.drawString("行動を終了しますか？",dc.viewSize+MARGIN,sy);
      	break;
    }
  }

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

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

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

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

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

//--------------------------------------------------------------------//
  void drawTurn(Graphics g){
// ターン情報描画
    FontMetrics fm=bg.getFontMetrics();
    int sx1,sx2;

    sx1=fm.stringWidth(dc.nation[dc.currentNation].name)+dc.viewSize+2*MARGIN;
    sx2=sx1+fm.stringWidth("の戦略")+MARGIN;
    g.setColor(dc.nation[dc.currentNation].color);
    g.drawString(dc.nation[dc.currentNation].name,dc.viewSize+MARGIN,sy);
    g.setColor(textColor);
    g.drawString("の戦略",sx1,sy);
    g.drawString(" ターン "+turn,sx2,sy);
  }

//--------------------------------------------------------------------//
  void drawDivisionControlPanel(Graphics g){
// 部隊コントロールパネル表示
    int nati=dc.grid[mapPoint].nation,div=dc.grid[mapPoint].division;
    switch(dc.nation[nati].division[div].status){
      case Division.WAIT:
      	move.draw(g,backColor,textColor);
      	attack.draw(g,backColor,textColor);
      	direction.draw(g,backColor,textColor);
      	formation.draw(g,backColor,textColor);
      	train.draw(g,backColor,textColor);
      	end.draw(g,backColor,textColor);
      	if(dc.gridNation(mapPoint)==dc.playerNation){
      	  supply.draw(g,backColor,textColor);
      	  construct.draw(g,backColor,textColor);
      	}
      	else if(dc.grid[mapPoint].castle){
      	  occupy.draw(g,backColor,textColor);
      	}
      	break;
      case Division.MOVED:
      	attack.draw(g,backColor,textColor);
      	direction.draw(g,backColor,textColor);
      	formation.draw(g,backColor,textColor);
      	train.draw(g,backColor,textColor);
      	end.draw(g,backColor,textColor);
      	if(dc.gridNation(mapPoint)==dc.playerNation){
      	  supply.draw(g,backColor,textColor);
      	  construct.draw(g,backColor,textColor);
      	}
      	else if(dc.grid[mapPoint].castle){
      	  occupy.draw(g,backColor,textColor);
      	}
      	break;
      case Division.DONE:
      	done.draw(g,backColor,textColor);
      	break;
    }
  }

//--------------------------------------------------------------------//
  void drawConstructPanel(Graphics g){
// 建設パネル表示
    constructFood.draw(g,backColor,textColor);
    constructMoney.draw(g,backColor,textColor);
    constructClass.draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawControlPanel(Graphics g){
// コントロールパネル表示
    globalMap.draw(g,backColor,textColor);
    divList.draw(g,backColor,textColor);
    nationList.draw(g,backColor,textColor);
    turnEnd.draw(g,backColor,textColor);
  }

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

//--------------------------------------------------------------------//
  void drawDecidePanel(Graphics g){
// 決定ボタンパネル表示
    decide.draw(g,backColor,textColor);
    cancel.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[ImageData.CURSOR],x0,y0,this);
  }

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

    if(mousex>=dc.viewSize || mousey>=dc.viewSize) return;
    cx=dc.gridSize2*DataCore.GRID;
    cy=dc.gridSize2*DataCore.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);
    x1=x0-cx/2;
    y1=y0-cy/2;
    g.setColor(textColor);
    g.drawRect(x1,y1,cx,cy);
    g.drawRect(x1+1,y1+1,cx-2,cy-2);
  }

//--------------------------------------------------------------------//
  void drawCursorDivisionList(Graphics g){
// 部隊リストでのカーソルの描画
    int x0,y0;

    x0=1;
    if(currentIndex<dc.nation[dc.currentNation].divisionNumber){
      y0=currentIndex*sy+MARGIN/2;
      g.setColor(textColor);
      g.drawRect(x0,y0,fx-2,sy);
    }
  }

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

    x0=1;
    if(currentIndex<dc.nationNumber){
      y0=currentIndex*sy+MARGIN/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=5+dc.formation.formDivision1.generalNumber;
    }
    else{
      x0=1+fx/2;
      indexMax=5+dc.formation.formDivision2.generalNumber;
    }
    if(0<=currentIndex && currentIndex<indexMax){
      y0=(currentIndex+2)*sy+MARGIN/2;
      g.setColor(textColor);
      g.drawRect(x0,y0,fx/2-2,sy);
    }
  }

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

    if(mousex<fx/2){
      x0=1;
      indexMax=2;
    }
    else{
      x0=1+fx/2;
      indexMax=3;
    }
    if(0<=currentIndex && currentIndex<indexMax){
      y0=(currentIndex+2)*sy+MARGIN/2;
      g.setColor(textColor);
      g.drawRect(x0,y0,fx/2-2,sy);
    }
  }

//--------------------------------------------------------------------//
  void drawError(Graphics g,String message){
// エラーメッセージ表示
    int sx,sy;
    FontMetrics fm=g.getFontMetrics();
    sx=fm.stringWidth(message);
    sy=fm.getHeight();
    g.setColor(backColor);
    g.fillRect((fx-sx-MARGIN)/2,(fy-sy-MARGIN)/2,sx+MARGIN,sy+MARGIN);
    g.setColor(textColor);
    g.drawString(message,(fx-sx)/2,(fy+sy)/2);
  }
}

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

//--------------------------------------------------------------------//
  ControlButton(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;
  }

//--------------------------------------------------------------------//
  void draw(Graphics g,Color backColor,Color textColor){
// ボタン描画
    int sx,sy;
    FontMetrics fm=g.getFontMetrics();
    sx=fm.stringWidth(label);
    sy=fm.getHeight();
    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,x0+(x-sx)/2,y0+(y+sy)/2);
  }

//--------------------------------------------------------------------//
  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 DataCore extends Panel{
  static final int NONE=-1;              // ボタン・パネル選択
  static final int GAME=0;               // ゲーム続行
  static final int GAMEOVER=-1;          // ゲームオーバー
  static final int GAMEWIN=1;            // ゲーム勝利

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

  static final int NMAX=50;              // 国家数の上限
  static final int WMAX=50;              // 兵種数の上限
  static final int GMAX=1000;            // 武将数の上限
  static final int FMAX=100000;          // フィールドデータの上限
  static final int IMAX=100;             // フィールド部品種類数の上限
  static final int CMAX=100;             // 城の数の上限
  static final int GRID=10;              // 描画範囲内のマス目の数
  static final int GHALF=5;
  static final int MOVING=10;            // 移動コマ最大数
  static final int MINIMUM=-10000;       // 最小値
  static final int COST=100;             // 建設コスト

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

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

  String fieldName;                      // フィールド名
  FieldParts fp[]=new FieldParts[IMAX];  // フィールド部品クラス
  Castle castle[]=new Castle[CMAX];      // 城クラス
  Grid grid[]=new Grid[FMAX];            // フィールドデータ
  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;
  Formation formation;                   // 部隊編成クラス
  Supply supply;                         // 部隊補給クラス
  Color backColor,textColor;             // 背景・文字表示色
  int movingPoint[]=new int[MOVING];     // 移動状態での部隊位置
  int movingDirection[]=new int[MOVING]; // 移動状態での部隊の方向
  int moving=0;                          // 移動コマ数
  int playerNation=0;                    // プレイヤーの国家
  boolean battle=false;                  // 戦闘中フラッグ
  int moveTarget=0;

  DataCore(InputStream is,Image image,int imageSize
      	  ,Color backColor,Color textColor)
    throws IOException,FileFormatException{

    this.backColor=backColor;
    this.textColor=textColor;
    img=new ImageData(image,imageSize);
    readData(is);
    setDivFlag();
  }

//--------------------------------------------------------------------//
  void readData(InputStream is)
    throws IOException,FileFormatException{
// 全体データ読み込み
    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();
    if(st.ttype!=StreamTokenizer.TT_EOF)
      throw new FileFormatException(st.toString());
  }

//--------------------------------------------------------------------//
  void readFieldPartsData(StreamTokenizer st) throws IOException{
// フィールド部品データ読み込み
    String name;
    int array[]=new int[7];
    int i,ii,move,effect,image,rr,gg,bb;
    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,7);
      ii=array[0];
      move=array[1];
      effect=array[2];
      image=array[3];
      rr=array[4];
      gg=array[5];
      bb=array[6];
      color=new Color(rr,gg,bb);
      fp[ii]=new FieldParts(name,move,effect,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;
      	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].division[div].dx,GHALF),nx-GHALF);
    viewy=Math.min(Math.max(nation[nati].division[div].dy,GHALF),ny-GHALF);
  }

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

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

//--------------------------------------------------------------------//
  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,pt;

    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);
    pt=nx*iy+ix;
    return pt;
  }

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

    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);
    pt=nx*iy+ix;
    return pt;
  }

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

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

    dx=grid[point].x-nation[currentNation].division[currentDivision].dx;
    dy=grid[point].y-nation[currentNation].division[currentDivision].dy;
    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].division[div].dx,nation[nati].division[div].dy
      	      	,nation[nati].division[div].move);
  }

//--------------------------------------------------------------------//
  boolean setMoveDistance(int pt){
// 部隊移動可能範囲の設定
    int nati=grid[pt].nation,div=grid[pt].division;
    if(nati==currentNation && div!=NONE){
      currentDivision=div;
      clearMoveDistance();
      FindDistance(nation[nati].division[div].dx,nation[nati].division[div].dy
      	      	  ,nation[nati].division[div].move);
      return true;
    }
    else{
      currentDivision=NONE;
      return false;
    }
  }

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

    xy=y*nx+x;
    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;

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

//--------------------------------------------------------------------//
  void moveDraw(int step){
// 部隊移動描画
    int point,x,y;
    point=movingPoint[step];
    x=nation[currentNation].division[currentDivision].dx;
    y=nation[currentNation].division[currentDivision].dy;
    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 pt){
// 部隊攻撃可能範囲の設定
    int nati=grid[pt].nation,div=grid[pt].division;
    if(nati==currentNation && div!=NONE){
      currentDivision=div;
      clearAttackDistance();
      FindAttack(grid[pt].x,grid[pt].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,dx,dy,direc;
    if(nati!=currentNation && div!=NONE){
      if(grid[point].attackDistance>=0){
      	dx=grid[point].x-nation[currentNation].division[currentDivision].dx;
      	dy=grid[point].y-nation[currentNation].division[currentDivision].dy;
      	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);
      	attackedNation=nati;
      	attackedDivision=div;
      	return;
      }
    }
    currentDivision=NONE;
  }

//--------------------------------------------------------------------//
  void setAttackDivision(int point,int nati,int div){
// 部隊攻撃の設定
    int dx,dy,direc;
    if(nati!=currentNation && div!=NONE){
      dx=grid[point].x-nation[currentNation].division[currentDivision].dx;
      dy=grid[point].y-nation[currentNation].division[currentDivision].dy;
      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);
      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;
    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);
    }
    deleteDivision(attackedNation,attackedDivision);
    deleteDivision(currentNation,currentDivision);
    battle=false;
    attackedDivision=NONE;
  }

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

    if(nation[nati].division[div].number==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==Nation.ROYALDIVISION){                      // 第1部隊全滅
      	ndiv=nation[nati].divisionNumber;
      	for(i=0;i<ndiv;i++){
      	  for(j=0;j<nation[nati].division[i].generalNumber;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();
      	if(nati==playerNation){
      	  gameOver();
      	}
      	else if(nati==currentNation){
      	  nextNation();
      	}
      }
      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].division[div].generalNumber;i++){
      	  ip=nation[nati].division[div].general[i].id;
      	  while((nation[nati].division[ndiv].generalNumber>=Division.GENERAL || 
      	      	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 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,dx,dy,direc;
    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 0:
      	  formation.foodExchange1(food);
      	  break;
      	case 1:
      	  formation.foodExchange2(food);
      	  break;
      }
    }
  }

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

//--------------------------------------------------------------------//
  void numberExchange(int direc,int number){
// 兵士交換
    if(formation!=null){
      switch(direc){
      	case 0:
      	  formation.numberExchange1(number);
      	  break;
      	case 1:
      	  formation.numberExchange2(number);
      	  break;
      }
    }
  }

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

//--------------------------------------------------------------------//
  void formationSet(int point){
// 部隊編成の決定
    if(formation==null) return;
    if(formation.formDivision1.number>0 && formation.formDivision2.number>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.formDivision1.number==0 && 
      	    formation.formDivision1.generalNumber==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.formDivision2.number==0 && 
      	    formation.formDivision2.generalNumber==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 0:
      	  supply.foodDivisionToCastle(food);
      	  break;
      	case 1:
      	  supply.foodCastleToDivision(food);
      	  break;
      }
    }
  }

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

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

//--------------------------------------------------------------------//
  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].foodProduct<Castle.MAXPARAMETER &&
       nation[currentNation].division[currentDivision].money>=COST){
      nation[currentNation].useMoney(currentDivision,COST);
      castle[grid[point].field].constructFoodProduct
      	(nation[currentNation].division[currentDivision].Construct());
      actionDone();
    }
  }

//--------------------------------------------------------------------//
  void constructMoneyProduct(int point){
// 城の商業開発
    if(castle[grid[point].field].moneyProduct<Castle.MAXPARAMETER &&
       nation[currentNation].division[currentDivision].money>=COST){
      nation[currentNation].useMoney(currentDivision,COST);
      castle[grid[point].field].constructMoneyProduct
      	(nation[currentNation].division[currentDivision].Construct());
      actionDone();
    }
  }

//--------------------------------------------------------------------//
  void constructCastleClass(int point){
// 城の規模拡大
    if(castle[grid[point].field].castleClass<Castle.MAXPARAMETER &&
       nation[currentNation].division[currentDivision].money>=COST){
      nation[currentNation].useMoney(currentDivision,COST);
      castle[grid[point].field].constructCastleClass
      	(nation[currentNation].division[currentDivision].Construct());
      actionDone();
    }
  }

//--------------------------------------------------------------------//
  boolean Training(){
// 部隊訓練
    if(nation[currentNation].division[currentDivision].train
      <Division.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>=0){
      	setAttackDistance(i,div);
      	for(j=0;j<nfield;j++){
      	  if(grid[j].attackDistance>=0 && grid[j].division!=NONE){
      	    point=grid[i].moveDistance-grid[j].attackDistance;
      	    if(point>evalPoint){
      	      evalPoint=point;
      	      moveTarget=i;
      	      attackedNation=grid[j].nation;
      	      attackedDivision=grid[j].division;
      	    }
      	  }
      	}
      }
    }
  }

//--------------------------------------------------------------------//
  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(){
// 行動終了
    nation[currentNation].actionDone(currentDivision);
  }

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

    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 gameOver(){
// ゲームオーバー
    game=GAMEOVER;
  }

//--------------------------------------------------------------------//
  void checkComplete(){
// ゲームクリアのチェック
    int i,enemy=0;
    for(i=0;i<nationNumber;i++){
      if(i!=playerNation && nation[i].divisionNumber!=0) enemy++;
    }
    if(enemy==0) game=GAMEWIN;
  }

//--------------------------------------------------------------------//
  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].division[i].dx-viewx+GHALF);
      	y0=gridSize*(nation[j].division[i].dy-viewy+GHALF);
      	if(x0<viewSize && y0<viewSize){
      	  nation[j].drawDivisionLocal(g,i,gridSize,x0,y0);
      	}
      }
    }
    if(battle){
      g.setColor(frameColor);
      x0=gridSize*(nation[currentNation].division[currentDivision].dx
      	      	  -viewx+GHALF);
      y0=gridSize*(nation[currentNation].division[currentDivision].dy
      	      	  -viewy+GHALF);
      g.fillRect(x0,y0,gridSize,gridSize);
      if(attackedDivision!=NONE){
      	x0=gridSize*(nation[attackedNation].division[attackedDivision].dx
      	      	    -viewx+GHALF);
      	y0=gridSize*(nation[attackedNation].division[attackedDivision].dy
      	      	    -viewy+GHALF);
      	g.fillRect(x0,y0,gridSize,gridSize);
      }
    }
  }

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

    for(j=0;j<nationNumber;j++){
      for(i=0;i<nation[j].divisionNumber;i++){
      	x0=gridSize2*nation[j].division[i].dx;
      	y0=gridSize2*nation[j].division[i].dy;
      	nation[j].drawDivisionGlobal(g,i,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[ImageData.SELECT],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[ImageData.SELECT],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[ImageData.SELECT],x0,y0,this);
      	}
      	ii++;
      }
      jj++;
    }
  }

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

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

//--------------------------------------------------------------------//
  void drawDivisionList(Graphics g,int sy){
// 部隊リストの描画
    int i,x0=5,y0=0;

    for(i=0;i<nation[currentNation].divisionNumber;i++){
      y0+=sy;
      nation[currentNation].drawDivisionList(g,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,int pt,int x0,int y0,int fx,int fy,int sy){
// ステータスの描画
    int nati=grid[pt].nation,div=grid[pt].division;

    g.setColor(backColor);
    g.fillRect(x0,y0,fx,fy);
    if(div!=NONE){
      drawDivStatus(g,nati,div,x0,y0,fx,fy,sy);
      y0+=sy*(nation[nati].division[div].generalNumber+7);
    }
    drawFieldStatus(g,pt,x0,y0,fx,fy,sy);
  }

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

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

//--------------------------------------------------------------------//
// 部隊編成クラス
class Formation{
  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){
// 兵糧交換
    food=Math.max((formDivision1.food-1)%food+1,0);
    food=Math.min(food,Division.MAXNUMBER-formDivision2.food);
    int foodloss=-food;
    formDivision1.SupplyFood(foodloss);
    formDivision2.SupplyFood(food);
  }

//--------------------------------------------------------------------//
  void foodExchange2(int food){
// 兵糧交換
    food=Math.max((formDivision2.food-1)%food+1,0);
    food=Math.min(food,Division.MAXNUMBER-formDivision1.food);
    int foodloss=-food;
    formDivision1.SupplyFood(food);
    formDivision2.SupplyFood(foodloss);
  }

//--------------------------------------------------------------------//
  void moneyExchange1(int money){
// 所持金交換
    money=Math.max((formDivision1.money-1)%money+1,0);
    money=Math.min(money,Division.MAXNUMBER-formDivision2.money);
    int moneyloss=-money;
    formDivision1.SupplyMoney(moneyloss);
    formDivision2.SupplyMoney(money);
  }

//--------------------------------------------------------------------//
  void moneyExchange2(int money){
// 所持金交換
    money=Math.max((formDivision2.money-1)%money+1,0);
    money=Math.min(money,Division.MAXNUMBER-formDivision1.money);
    int moneyloss=-money;
    formDivision1.SupplyMoney(money);
    formDivision2.SupplyMoney(moneyloss);
  }

//--------------------------------------------------------------------//
  void numberExchange1(int number){
// 兵士交換
    number=Math.max((formDivision1.number-1)%number+1,0);
    number=Math.min(number,Division.MAXNUMBER-formDivision2.number);
    formDivision2.SupplySoldier(number,formDivision1.train);
    formDivision1.Damage(number);
  }

//--------------------------------------------------------------------//
  void numberExchange2(int number){
// 兵士交換
    number=Math.max((formDivision2.number-1)%number+1,0);
    number=Math.min(number,Division.MAXNUMBER-formDivision1.number);
    formDivision1.SupplySoldier(number,formDivision2.train);
    formDivision2.Damage(number);
  }

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

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

//--------------------------------------------------------------------//
  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{
  static final int NEWSOLDIER=10;  // 新兵の訓練度

  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){
// 兵糧交換
    food=Math.max((division.food-1)%food+1,0);
    food=Math.min(food,Castle.MAXNUMBER-castle.food);
    int foodloss=-food;
    division.SupplyFood(foodloss);
    castle.SupplyFood(food);
  }

//--------------------------------------------------------------------//
  void foodCastleToDivision(int food){
// 兵糧交換
    food=Math.max((castle.food-1)%food+1,0);
    food=Math.min(food,Division.MAXNUMBER-division.food);
    int foodloss=-food;
    division.SupplyFood(food);
    castle.SupplyFood(foodloss);
  }

//--------------------------------------------------------------------//
  void moneyDivisionToCastle(int money){
// 資金交換
    money=Math.max((division.money-1)%money+1,0);
    money=Math.min(money,Castle.MAXNUMBER-castle.money);
    int moneyloss=-money;
    division.SupplyMoney(moneyloss);
    castle.SupplyMoney(money);
  }

//--------------------------------------------------------------------//
  void moneyCastleToDivision(int money){
// 資金交換
    money=Math.max((castle.money-1)%money+1,0);
    money=Math.min(money,Division.MAXNUMBER-division.money);
    int moneyloss=-money;
    division.SupplyMoney(money);
    castle.SupplyMoney(moneyloss);
  }

//--------------------------------------------------------------------//
  void soldierSupply(){
// 募兵
    int soldier=10*(division.politics+division.charisma)*castle.castleClass
      	       /Castle.MAXPARAMETER;
    if(division.money>=division.weapon.cost){
      division.useMoney(division.weapon.cost);
      division.SupplySoldier(soldier,NEWSOLDIER);
    }
  }

//--------------------------------------------------------------------//
  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 ImageData extends Panel{
  static final int CURSOR=0;         // カーソル部品
  static final int SELECT=1;         // 選択範囲部品
  static final int NMAX=100;         // テンプレート大きさ・部品数の上限

  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(SELECT);
  }

//--------------------------------------------------------------------//
  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 FieldParts extends Panel{
  static final int MOVEMAX=5;  // 必要機動力の上限

  String name;         // フィールド部品名
  int move;            // フィールド部品移動必要機動力
  int effect;          // フィールド部品地形効果
  Image image;         // フィールド部品イメージ
  Color color;         // フィールド部品表示色

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

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

//--------------------------------------------------------------------//
  void drawParameter(Graphics g,int x0,int y0,int sy
      	      	    ,int x,int y){
// 地形情報の表示
    int gx=image.getWidth(this),gy=image.getHeight(this);
    x++; y++;
    g.drawImage(image,x0,y0+fieldPanel.MARGIN,this);
    x0+=gx+fieldPanel.MARGIN;
    y0+=sy;
    g.drawString(name+" x="+x+" y="+y,x0,y0);
    if(move>MOVEMAX){
      g.drawString("必要機動力： ∞",x0,y0+sy);
    }
    else{
      g.drawString("必要機動力： "+move,x0,y0+sy);
    }
    g.drawString("地形効果： "+effect,x0,y0+2*sy);
  }
}

//--------------------------------------------------------------------//
// 城クラス
class Castle extends FieldParts{
  static final int MAXNUMBER=10000;   // 物資の上限
  static final int MAXPARAMETER=1000; // パラメータの上限

  int food;                           // 兵糧
  int money;                          // 資金
  int foodProduct;                    // 農業生産
  int moneyProduct;                   // 商業生産
  int castleClass;                    // 城郭規模
  int x,y;                            // 城の位置
  int nation=DataCore.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,image,color);
    this.food=Math.min(food,MAXNUMBER);
    this.money=Math.min(money,MAXNUMBER);
    this.foodProduct=Math.min(foodProduct,MAXPARAMETER);
    this.moneyProduct=Math.min(moneyProduct,MAXPARAMETER);
    this.castleClass=Math.min(castleClass,MAXPARAMETER);
    this.x=x;
    this.y=y;
    effect=3+(int)(3.0*Math.sqrt((double)castleClass/(double)MAXPARAMETER));
  }

  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);
  }

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

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

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

//--------------------------------------------------------------------//
  void constructCastleClass(int construct){
// 城の規模拡大
    castleClass=Math.min(castleClass+construct,MAXPARAMETER);
    effect=3+(int)(3.0*Math.sqrt((double)castleClass/(double)MAXPARAMETER));
  }

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

    gx=image.getWidth(this);
    gy=image.getHeight(this);
    sx1=fm.stringWidth("兵糧： "+MAXNUMBER)+fieldPanel.MARGIN;
    sx2=fm.stringWidth("農業生産： "+MAXPARAMETER)+fieldPanel.MARGIN;
    sx=Math.max(sx1,sx2);
    x++; y++;
    g.drawImage(image,x0,y0+fieldPanel.MARGIN,this);
    if(nation!=DataCore.NONE){
      g.setColor(nationColor);
      g.drawRect(x0,y0+fieldPanel.MARGIN,gx,gy);
    }
    g.setColor(textColor);
    g.drawString(name+" x="+x+" y="+y,x0+gx+fieldPanel.MARGIN,y0+sy);
    if(move>MOVEMAX){
      g.drawString("必要機動力： ∞",x0+gx+fieldPanel.MARGIN,y0+2*sy);
    }
    else{
      g.drawString("必要機動力： "+move,x0+gx+fieldPanel.MARGIN,y0+2*sy);
    }
    g.drawString("地形効果： "+effect,x0+gx+fieldPanel.MARGIN,y0+3*sy);
    y0+=Math.max(gy,3*sy);
    g.drawString("兵糧： "+food,x0,y0+sy);
    g.drawString("農業生産： "+foodProduct,x0+sx,y0+sy);
    g.drawString("資金： "+money,x0,y0+2*sy);
    g.drawString("商業生産： "+moneyProduct,x0+sx,y0+2*sy);
    g.drawString("城郭規模： "+castleClass,x0,y0+3*sy);
  }

//--------------------------------------------------------------------//
  void drawSupply(Graphics g,int x0,int y0,int sy){
// 部隊補給の描画
    g.drawString(name,x0,y0);
    g.drawString("兵糧： "+food,x0,y0+sy);
    g.drawString("所持金： "+money,x0,y0+2*sy);
    g.drawString("募兵",x0,y0+3*sy);
  }
}

//--------------------------------------------------------------------//
// フィールドデータクラス
class Grid{
  int x,y;                 // グリッド座標
  int field;               // フィールドデータ
  int nation=-1;           // 領有国家
  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{
  static final int DMAX=100;         // 部隊数の上限
  static final int ROYALDIVISION=0;  // 王の所属する部隊

  String name,kingName;              // 国家名・王の名
  Color color,textColor;             // 国家色
  int divisionNumber=0;              // 国家内の部隊数
  Division division[]=new Division[DMAX];       // 部隊クラス

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

//--------------------------------------------------------------------//
  void addDivision(int id,String name,int nation,int number,int train
      	      	  ,int food,int money,int dx,int dy,int direction
      	      	  ,Weapon weapon){
// 部隊の追加
    division[id]=new Division(id,name,nation,number,train,food,money,dx,dy
      	      	      	     ,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]);
    }
    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]);
    }
  }

//--------------------------------------------------------------------//
  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);
  }

//--------------------------------------------------------------------//
  void moveDivision(int div,int dx,int dy,int direction){
// 部隊の移動
    division[div].moveDivision(dx,dy,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();
  }

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

//--------------------------------------------------------------------//
  void useMoney(int div,int cost){
// 部隊の資金使用
    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 AttackRange(int div){
// 攻撃射程
    return division[div].weapon.attackRange;
  }

//--------------------------------------------------------------------//
  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){
// 国家リストの描画
    FontMetrics fm=g.getFontMetrics();
    int sx=fm.stringWidth(name+" ");
    int i,number=0,general=0;
    String line=" ";

    if(divisionNumber>0){
      for(i=0;i<divisionNumber;i++){
      	number+=division[i].number;
      	general+=division[i].generalNumber;
      }
      g.setColor(color);
      g.drawString(name,x0,y0);
      g.setColor(textColor);
      line+=" 君主："+kingName;
      line+=" 兵数："+number;
      line+=" 部隊数："+divisionNumber;
      line+=" 武将数："+general;
      g.drawString(line,x0+sx,y0);
    }
  }

//--------------------------------------------------------------------//
  void drawDivisionList(Graphics g,int div,int x0,int y0){
// 部隊リストの描画
    FontMetrics fm=g.getFontMetrics();
    int sx=fm.stringWidth(name+" ");

    g.setColor(color);
    g.drawString(name,x0,y0);
    g.setColor(textColor);
    division[div].drawDivisionList(g,x0+sx,y0);
  }

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

//--------------------------------------------------------------------//
// 部隊クラス
class Division{
  static final int GENERAL=10;        // 部隊所属将軍数の上限
  static final int MAXNUMBER=10000;   // 物資・兵力の上限
  static final int MAXPARAMETER=100;  // パラメータの上限
  static final int MINPARAMETER=10;   // パラメータの下限
  static final int EAT=30;            // 兵糧消費期間
  static final double ESCAPE=0.1;     // 兵士脱走率

  static final int WAIT=0;            // 部隊の状態
  static final int MOVED=1;
  static final int DONE=2;

  int id;              // 部隊番号
  String name;         // 部隊名
  int nation;          // 部隊が所属する国家
  int number;          // 部隊兵数
  int train;           // 部隊訓練度
  int food;            // 所持兵糧
  int money;           // 所持金
  int generalNumber=0; // 部隊内の武将数
  int dx,dy;           // 部隊の位置
  int politics;        // 所属武将の政略の最大値
  int strategy;        // 所属武将の知略の最大値
  int command;         // 所属武将の指揮の最大値
  int strength;        // 所属武将の武力の最大値
  int charisma;        // 所属武将の魅力の最大値
  int attack;          // 部隊の攻撃力
  int defense;         // 部隊の防御力
  int move;            // 部隊の機動力
  int direction;       // 部隊の向いている方向
  int status=WAIT;     // 部隊の状態
  General general[]=new General[GENERAL];  // 部隊所属将軍
  Weapon weapon;       // 兵種

  Division(int id,String name,int nation,int number,int train
      	  ,int food,int money,int dx,int dy,int direction
      	  ,Weapon weapon){
    this.id=id;
    this.name=name;
    this.food=food;
    this.money=money;
    this.nation=nation;
    this.number=Math.min(number,MAXNUMBER);
    this.train=Math.min(train,MAXPARAMETER);
    this.dx=dx;
    this.dy=dy;
    this.direction=direction;
    this.weapon=weapon;
    setParameter();
  }

  Division(int id,Division division){
    this.id=id;
    this.name=division.name;
    this.food=division.food;
    this.money=division.money;
    this.nation=division.nation;
    this.number=Math.min(division.number,MAXNUMBER);
    this.train=Math.min(division.train,MAXPARAMETER);
    this.dx=division.dx;
    this.dy=division.dy;
    this.direction=division.direction;
    this.weapon=division.weapon;
    setParameter();
  }

//--------------------------------------------------------------------//
  void addGeneral(General gen){
// 部隊所属将軍の追加
    if(generalNumber>=GENERAL) 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(){
// 部隊パラメータの設定
    double numcoef;

    numcoef=Math.sqrt((double)number);
    attack=(int)(numcoef*weapon.attack*((double)(strength+command)+0.5*train));
    defense=(int)(0.5*weapon.defense*(command+train));
    move=weapon.move+(int)(0.0125*(command+train));
  }

//--------------------------------------------------------------------//
  void moveDivision(int dx,int dy,int direction){
// 部隊の移動
    this.dx=dx;
    this.dy=dy;
    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 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 train2){
// 兵士補充
    int number2=Math.min(number+supply,MAXNUMBER);
    train=(number*train+(number2-number)*train2)/number2;
    number=number2;
    setDivisionParameter();
  }

//--------------------------------------------------------------------//
  void useMoney(int cost){
// 部隊の資金使用
    money=Math.max(money-cost,0);
  }

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

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

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

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

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

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

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

    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){
// 部隊リストの描画
    String line=" ";

    if(name.equals("null")){
      line+=this.name="第"+(id+1)+"軍";
    }
    else{
      line+=name;
    }
    line+=" 兵糧："+food;
    line+=" 所持金："+money;
    line+=" 兵数："+number;
    line+=" 訓練度："+train;
    line+=" 兵種： "+weapon.name;
    line+=" 武将数："+generalNumber;
    line+=" 位置： x="+dx+" y="+dy;
    switch(status){
      case WAIT:
      	line+=" 待機";
      	break;
      case MOVED:
      	line+=" 移動済";
      	break;
      case DONE:
      	line+=" 行動済";
      	break;
    }
    g.drawString(line,x0,y0);
  }

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

    if(name.equals("null")){
      g.drawString("第"+(id+1)+"軍",x0,y0);
    }
    else{
      g.drawString(name,x0,y0);
    }
    g.drawString("兵糧： "+food,x0,y0+sy);
    g.drawString("所持金： "+money,x0,y0+2*sy);
    g.drawString("兵数： "+number,x0,y0+3*sy);
    g.drawString("訓練度： "+train,x0,y0+4*sy);
    g.drawString("武将数： "+generalNumber,x0,y0+5*sy);
    ssy=y0+6*sy;
    for(i=0;i<generalNumber;i++){
      g.drawString(general[i].name,x0+10,ssy);
      ssy+=sy;
    }
  }

//--------------------------------------------------------------------//
  void drawParameter(Graphics g,int x0,int y0,int sx,int sy){
// 部隊情報の表示
    int i,ssy;

    if(name.equals("null")){
      g.drawString("第"+(id+1)+"軍",x0+sx,y0);
    }
    else{
      g.drawString(name,x0+sx,y0);
    }
    g.drawString("兵糧： "+food+"  所持金： "+money,x0,y0+sy);
    g.drawString("兵数： "+number+"  訓練度： "+train,x0,y0+2*sy);
    g.drawString("兵種： "+weapon.name+"  機動力： "+move,x0,y0+3*sy);
    g.drawString("武将数： "+generalNumber,x0,y0+4*sy);
    g.drawString("武将名　 政略 知略 指揮 武力 魅力",x0+fieldPanel.MARGIN,y0+5*sy);
    ssy=y0+6*sy;
    for(i=0;i<generalNumber;i++){
      general[i].drawParameter(g,x0+fieldPanel.MARGIN,ssy);
      ssy+=sy;
    }
  }
}

//--------------------------------------------------------------------//
// 兵種クラス
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{
  static final int MAXPARAMETER=100;       // パラメータの上限

  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(Graphics g,int x0,int y0){
// 武将情報の表示
    int dx,x1;

    FontMetrics fm=g.getFontMetrics();
    dx=fm.stringWidth(" 政略");
    x1=x0+fm.stringWidth("４文字分 ");
    g.drawString(name,x0,y0);
    g.drawString(" "+politics,x1,y0);
    g.drawString(" "+strategy,x1+dx,y0);
    g.drawString(" "+command,x1+2*dx,y0);
    g.drawString(" "+strength,x1+3*dx,y0);
    g.drawString(" "+charisma,x1+4*dx,y0);
  }
}

//--------------------------------------------------------------------//
// ファイル書式例外処理
class FileFormatException extends Exception{
  public FileFormatException(String s){
    super(s);
  }
}

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

  ClearFilter(int r,int g,int b){
    rgbColor=(255<<24)|(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 0x88000000|(rgb&0x00FFFFFF);
  }
}

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

  drawDivision(){}

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

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