//--------------------------------------------------------------------//
//   3DダンジョンRPG ver.1.1					      //
//--------------------------------------------------------------------//
// クラス一覧
//  interface Parameters      パラメータインターフェイス
//  interface Message         メッセージインターフェイス
//  class DungeonRPG          メイン
//  class DungeonViewPanel    ダンジョン表示部分
//  class ControlButton       コントロールボタンクラス
//  class StatusPanel         ステータス表示パネル
//  class DungeonMessagePanel メッセージパネル
//  class ItemListPanel       アイテムリストパネル
//  class ImageData           イメージクラス
//  class DungeonData         ダンジョンデータ
//  class Floor               階層データ
//  class MapGrid             マップ１マスのデータ
//  class MonsterMap          ワンダリングモンスター分布クラス
//  class KeyDoor             鍵付き扉クラス
//  class Event               イベントクラス
//  class Elevator            エレベータークラス
//  class Item                アイテムクラス
//  class Character           キャラクタークラス
//  class Player              プレイヤークラス
//  class Monster             モンスタークラス
//  class draw2D              ２次元マップ表示	
//  class draw3D              ３次元マップ表示	
//--------------------------------------------------------------------//

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

//--------------------------------------------------------------------//
// パラメータインターフェイス
interface Parameters{
  static final int UP1=38;      // キーコード
  static final int LEFT1=37;
  static final int RIGHT1=39;
  static final int DOWN1=40;
  static final int UP2=104;
  static final int LEFT2=100;
  static final int RIGHT2=102;
  static final int DOWN2=98;

  static final int NORTH=0;     // プレイヤーの向いている方向
  static final int EAST=1;
  static final int SOUTH=2;
  static final int WEST=3;

  static final int NONE=0;      // ボタン・パネル選択
  static final int MOVE=1;
  static final int FORWARD=2;
  static final int LEFT=3;
  static final int RIGHT=4;
  static final int BACK=5;
  static final int VIEWSW=6;
  static final int EVENT=7;
  static final int YESNO=8;
  static final int YES=9;
  static final int NO=10;
  static final int ELEVATOR=11;
  static final int BATTLE=12;
  static final int ATTACK=13;
  static final int ESCAPE=14;
  static final int ITEM=15;
  static final int USE=16;
  static final int DROP=17;

  static final int NOEVENT=0;   // イベント選択
  static final int START=1;
  static final int GOAL=2;
  static final int UPSTAIR=3;
  static final int DOWNSTAIR=4;
  static final int WARP1WAY=5;
  static final int WARP2WAY=6;
  static final int ELEVATORIN=7;
  static final int ITEMGET=8;
  static final int ENCOUNT=9;
  static final int MESSAGE=10;
  static final int HEAL=11;

  static final int NOSELECT=-1; // アイテム・エレベーター階層未選択
  static final int SELECT=1;    // イベント選択肢の種類
  static final int EVSELECT=2;
  static final int MSSWITCH[]=
      {NOSELECT,NOSELECT,NOSELECT,SELECT,SELECT,NOSELECT,NOSELECT,EVSELECT
      ,SELECT,NOSELECT,NOSELECT,SELECT};    // メッセージ表示の種類

  static final int VIEW3D=0;    // 視点選択
  static final int VIEW2D=1;

  static final int WALL=1;      // 壁データ
  static final int DOOR=2;

  static final int FLOORMAX=100;    // 階層の上限
  static final int EVENTMAX=1000;   // イベントの上限
  static final int WALLMAX=500000;  // 壁数の上限
  static final int MONSTERMAX=1000; // モンスター種類数の上限
  static final int EVFLOORMAX=100;  // 移動できるフロア数の上限
  static final int ITEMMAX=20;      // アイテム数の上限
  static final int MONSTER1MAP=10;  // 1マップ内モンスター種類数の上限
  static final int MONSTERITEM=10;  // モンスターが持っているアイテム種類数の上限
  static final int EVENTLINE=100;   // イベントメッセージ行数の上限
  static final int MESSAGELINE=30;  // 表示メッセージ行数の上限
  static final int DEPTH=10;        // 奥行きの最大値

  static final int KEY=0;       // アイテム種類
  static final int CURE=1;
  static final int WEAPON=2;
  static final int DEFEND=3;

  static final int LVMAX=100;   // レベルの最大値
  static final int NOEXP=0;     // 最大レベルでの次レベルの経験値表示

  static final double SIGMA=0.2/Math.PI;    // 攻撃ダメージの変動範囲
}

//--------------------------------------------------------------------//
// メッセージインターフェイス
interface Message{
  static final String
    PANELBUTTON[]={"前(8)","左(4)","右(6)","後(2)","はい(Y)","いいえ(N)"
                  ,"視点変換(C)","攻撃(A)","逃走(E)","アイテム(I)"
                  ,"使用(U)","捨てる(D)"};
  static final String PLAYERPARAM[]={"LV: ","HP: ","AT: ","DF: ","EXP: "};
  static final String SLASH="/";
  static final String WEAPON="武器：",DEFEND="防具：";
  static final String ENCOUNTMESSAGE="が現れた";
  static final String ATTACKED="の攻撃";
  static final String MONSTERDAMAGE="ポイントのダメージを与えた";
  static final String PLAYERDAMAGE="ポイントのダメージを受けた";
  static final String NI="に",HA="は";
  static final String ESCAPEMESSAGE="は逃げ出した";
  static final String ESCAPEOKMESSAGE="逃走に成功した";
  static final String ESCAPENGMESSAGE="逃走に失敗した！";
  static final String WINMESSAGE="を倒した";
  static final String EXP="経験値",POINTGETMESSAGE="ポイント獲得した";
  static final String LVUPMESSAGE="はレベルが上がった";
  static final String POINTUPMESSAGE="ポイント上昇した";
  static final String GETMESSAGE="を手に入れた";
  static final String MAXHP="最大HPが",ATTACKP="攻撃力が",DEFENCEP="防御力が";
  static final String DEADMESSAGE="は死亡しました";
  static final String USEMESSAGE="を使った",NOUSEMESSAGE="は使えない";
  static final String DROPMESSAGE="を捨てた",NODROPMESSAGE="は捨てられない";
  static final String CUREMESSAGE="ポイント回復";
  static final String EQUIPMESSAGE="を装備した";
  static final String YESNOSELECT="Yes(Y) / No(N)";
}

//--------------------------------------------------------------------//
// メイン
public class DungeonRPG extends Applet{
  DungeonViewPanel dpanel;
  String name,iname;
  private Color backColor=Color.black,textColor=Color.white;
  private Image template=null;

//--------------------------------------------------------------------//
  public void init(){
// データファイル名
    URL base=getDocumentBase();
    name=getParameter("mapdata");
    if (name==null) name="sumple.dgn";
    iname=getParameter("image");
    if (iname==null) iname="template.gif";
    getTemplateImage(iname);
    setLayout(new BorderLayout());
    dpanel=new DungeonViewPanel(base,name,template,backColor,textColor);
    add("Center",dpanel);
  }

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

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

//--------------------------------------------------------------------//
// ダンジョン表示部分
class DungeonViewPanel extends Panel
  implements MouseListener,KeyListener,Parameters,Message{
    DungeonData dd;
    StatusPanel spanel;
    String message;
    boolean waitsw=true;              // 表示待ちスイッチ
    int mapView=VIEW3D;               // 表示設定
    int event=START;                  // イベント
    int mode=EVENT;                   // 状態スイッチ
    int panelMode=MOVE;               // パネル表示スイッチ
    int button=NONE;                  // 押したボタン
    int itemIndex=NOSELECT;           // 選択したアイテム
    int elevatorFloor=NOSELECT;       // ボタンサブキー
    boolean setElevator=false;           // 表示待ちスイッチ
    int fx,fy,fxi,fyi,x0,y0,x1,y1,esize; // 地図表示サイズ・位置
    int depth=6;                      // 表示奥行き
    private Image bgImage;            // ダブルバッファリング用イメージ
    private Graphics bg;
    Color backColor,textColor;        // 背景色・文字色
    int fontsize1=18,fontsize2=12;    // 文字フォントの大きさ
    ControlButton forward,left,right,back,viewsw; // ボタン
    ControlButton yes,no,attack,escape,item,use,drop;
    ControlButton elevator[]=new ControlButton[FLOORMAX];

//--------------------------------------------------------------------//
  public DungeonViewPanel(URL base,String name,Image image
      	      	      	 ,Color backColor,Color textColor){
    this.backColor=backColor;
    this.textColor=textColor;
    getData(base,name,image);
    setBackground(backColor);
    addMouseListener(this);
    addKeyListener(this);
  }

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

    message=null;
    try{
      is=new URL(base,name).openStream();
      dd=new DungeonData(is,image);
    }
    catch(Exception e){
      message=e.toString();
    }
    try{
      if(is!=null) is.close();
    }
    catch(Exception e){}
  }

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

//--------------------------------------------------------------------//
  public void mousePressed(MouseEvent e){
    int mousex,mousey,i,flr=-1,index;

    if(waitsw) return;
    mousex=e.getX();
    mousey=e.getY();
    e.consume();

    if(panelMode==ITEM){
      mousePressedItem(mousex,mousey);
    }
    else{
      switch(mode){
      	case MOVE:
      	  mousePressedMove(mousex,mousey);
      	  break;
      	case EVENT:
      	  mousePressedEvent(mousex,mousey);
      	  break;
      	case BATTLE:
      	  mousePressedBattle(mousex,mousey);
      	  break;
      }
    }
    repaint();
  }

//--------------------------------------------------------------------//
  public void mouseReleased(MouseEvent e){
    if(waitsw) return;
    ReleasedAction();
    repaint();
  }

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

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

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

    if(waitsw) return;
    if(panelMode==ITEM){
      keyTypedItem(keyin);
    }
    else{
      switch(mode){
      	case MOVE:
      	  keyTypedMove(keyin);
      	  break;
      	case EVENT:
      	  keyTypedEvent(keyin);
      	  break;
      	case BATTLE:
      	  keyTypedBattle(keyin);
      	  break;
      }
    }
    repaint();
  }

//--------------------------------------------------------------------//
  public void keyReleased(KeyEvent e){
    if(waitsw) return;
    ReleasedAction();
    repaint();
  }

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

//--------------------------------------------------------------------//
  void ReleasedAction(){
// ボタン離し時実行
    switch(button){
      case FORWARD:
      	goAhead();
      	break;
      case LEFT:
      	turnLeft();
      	break;
      case RIGHT:
      	turnRight();
      	break;
      case BACK:
      	turnBack();
      	break;
      case YES:
      	eventOn(1);
      	break;
      case NO:
      	eventOff();
      	break;
      case VIEWSW:
      	changeView();
      	break;
      case ATTACK:
      	Attack();
      	break;
      case ESCAPE:
      	Escape();
      	break;
      case ITEM:
      	Item();
      	break;
      case USE:
      	Use(dd.ipanel.index);
      	break;
      case DROP:
      	Drop(dd.ipanel.index);
      	break;
      case ELEVATOR:
      	elevator[elevatorFloor].Release();
      	eventOn(elevatorFloor+2);
      	break;
    }
    button=NONE;
  }

//--------------------------------------------------------------------//
  void mousePressedItem(int mousex,int mousey){
// アイテム選択時マウス入力
    int index=dd.ipanel.selected(mousex,mousey);
    if(index==dd.ipanel.NOSELECT){
      if(use.press(mousex,mousey)){
      	button=USE;
      	use.Press();
      }
      else if(drop.press(mousex,mousey)){
      	button=DROP;
      	drop.Press();
      }
      else{
      	panelMode=mode;
      }
    }
  }

//--------------------------------------------------------------------//
  void mousePressedMove(int mousex,int mousey){
// 移動時マウス入力
    if(forward.press(mousex,mousey)){
      button=FORWARD;
      forward.Press();
    }
    else if(left.press(mousex,mousey)){
      button=LEFT;
      left.Press();
    }
    else if(right.press(mousex,mousey)){
      button=RIGHT;
      right.Press();
    }
    else if(back.press(mousex,mousey)){
      button=BACK;
      back.Press();
    }
    else if(viewsw.press(mousex,mousey)){
      button=VIEWSW;
      viewsw.Press();
    }
    else if(item.press(mousex,mousey)){
      button=ITEM;
      item.Press();
    }
  }

//--------------------------------------------------------------------//
  void mousePressedEvent(int mousex,int mousey){
// イベント時マウス入力
    int i;
    elevatorFloor=NOSELECT;
    switch(MSSWITCH[dd.event[event].type]){
      case SELECT:
      	if(yes.press(mousex,mousey)){
      	  button=YES;
      	  yes.Press();
      	}
      	else if(no.press(mousex,mousey)){
      	  button=NO;
      	  no.Press();
      	}
      	break;
      case EVSELECT:
      	for(i=0;i<dd.elev[dd.event[event].move].nfloor;i++){
      	  if(elevator[i].press(mousex,mousey)) elevatorFloor=i;
      	}
      	if(elevatorFloor!=NOSELECT){
      	  button=ELEVATOR;
      	  elevator[elevatorFloor].Press();
      	}
      	else{
      	  button=NO;
      	}
      	break;
      case NOSELECT:
      	button=NO;
      	no.Press();
      	break;
    }
  }

//--------------------------------------------------------------------//
  void mousePressedBattle(int mousex,int mousey){
// 戦闘時マウス入力
    if(attack.press(mousex,mousey)){
      button=ATTACK;
      attack.Press();
    }
    else if(escape.press(mousex,mousey)){
      button=ESCAPE;
      escape.Press();
    }
    else if(item.press(mousex,mousey)){
      button=ITEM;
      item.Press();
    }
  }

//--------------------------------------------------------------------//
  void keyTypedItem(int keyin){
// アイテム選択時キーボード入力
    switch(keyin){
      case KeyEvent.VK_2:
      	dd.ipanel.lowerIndex();
      	break;
      case KeyEvent.VK_8:
      	dd.ipanel.upperIndex();
      	break;
      case KeyEvent.VK_KP_DOWN:
      	dd.ipanel.lowerIndex();
      	break;
      case KeyEvent.VK_KP_UP:
      	dd.ipanel.upperIndex();
      	break;
      case DOWN1:
      	dd.ipanel.lowerIndex();
      	break;
      case UP1:
      	dd.ipanel.upperIndex();
      	break;
      case DOWN2:
      	dd.ipanel.lowerIndex();
      	break;
      case UP2:
      	dd.ipanel.upperIndex();
      	break;
      case KeyEvent.VK_C:
      	panelMode=mode;
      	dd.ipanel.Cancel();
      	break;
      case KeyEvent.VK_U:
      	button=USE;
      	use.Press();
      	break;
      case KeyEvent.VK_D:
      	button=DROP;
      	drop.Press();
      	break;
    }
  }

//--------------------------------------------------------------------//
  void keyTypedMove(int keyin){
// 移動時キーボード入力
    switch(keyin){
      case KeyEvent.VK_2:
      	button=BACK;
      	back.Press();
      	break;
      case KeyEvent.VK_4:
      	button=LEFT;
      	left.Press();
      	break;
      case KeyEvent.VK_5:
      	button=VIEWSW;
      	viewsw.Press();
      	break;
      case KeyEvent.VK_6:
      	button=RIGHT;
      	right.Press();
      	break;
      case KeyEvent.VK_8:
      	button=FORWARD;
      	forward.Press();
      	break;
      case KeyEvent.VK_KP_DOWN:
      	button=BACK;
      	back.Press();
      	break;
      case KeyEvent.VK_KP_LEFT:
      	button=LEFT;
      	left.Press();
      	break;
      case KeyEvent.VK_KP_RIGHT:
      	button=RIGHT;
      	right.Press();
      	break;
      case KeyEvent.VK_KP_UP:
      	button=FORWARD;
      	forward.Press();
      	break;
      case DOWN1:
      	button=BACK;
      	back.Press();
      	break;
      case LEFT1:
      	button=LEFT;
      	left.Press();
      	break;
      case RIGHT1:
      	button=RIGHT;
      	right.Press();
      	break;
      case UP1:
      	button=FORWARD;
      	forward.Press();
      	break;
      case DOWN2:
      	button=BACK;
      	back.Press();
      	break;
      case LEFT2:
      	button=LEFT;
      	left.Press();
      	break;
      case RIGHT2:
      	button=RIGHT;
      	right.Press();
      	break;
      case UP2:
      	button=FORWARD;
      	forward.Press();
      	break;
      case KeyEvent.VK_C:
      	button=VIEWSW;
      	viewsw.Press();
      	break;
      case KeyEvent.VK_I:
      	button=ITEM;
      	item.Press();
      	break;
    }
  }

//--------------------------------------------------------------------//
  void keyTypedEvent(int keyin){
// イベント時キーボード入力
    switch(keyin){
      case KeyEvent.VK_N:
      	button=NO;
      	no.Press();
      	break;
      case KeyEvent.VK_Y:
      	button=YES;
      	yes.Press();
      	break;
    }
  }

//--------------------------------------------------------------------//
  void keyTypedBattle(int keyin){
// 戦闘時キーボード入力
    switch(keyin){
      case KeyEvent.VK_A:
      	button=ATTACK;
      	attack.Press();
      	break;
      case KeyEvent.VK_E:
      	button=ESCAPE;
      	escape.Press();
      	break;
      case KeyEvent.VK_I:
      	button=ITEM;
      	item.Press();
      	break;
    }
  }

//--------------------------------------------------------------------//
  void goAhead(){
// 前に移動する処理
    int oldp,newp;
    if(mapView==VIEW3D && mode==MOVE){
      event=dd.goAhead();
      switch(MSSWITCH[dd.event[event].type]){
      	case SELECT:
      	  panelMode=YESNO;
      	  break;
      	case EVSELECT:
      	  panelMode=ELEVATOR;
      	  setElevator=true;
      	  break;
      }
      if(dd.event[event].type!=NOEVENT){
      	mode=EVENT;
      	dd.drawMessage(event);
      }
      else if(dd.currentEnemy!=null){
      	mode=BATTLE;
      	panelMode=BATTLE;
      }
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void turnRight(){
// 右を向く処理
    if(mapView==VIEW3D && mode==MOVE){
      dd.turnRight();
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void turnLeft(){
// 左を向く処理
    if(mapView==VIEW3D && mode==MOVE){
      dd.turnLeft();
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void turnBack(){
// 後を向く処理
    if(mapView==VIEW3D && mode==MOVE){
      dd.turnBack();
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void changeView(){
// 表示の変更
    if(panelMode==MOVE){
      mapView=VIEW2D+VIEW3D-mapView;
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void eventOn(int ynsw){
// イベント実行
    if(mode==EVENT){
      dd.eventAction(event,ynsw-2);
      repaint();
      afterEvent();
    }
  }

//--------------------------------------------------------------------//
  void eventOff(){
// イベントキャンセル
    if(mode==EVENT){
      if(MSSWITCH[dd.event[event].type]==NOSELECT){
      	dd.eventAction(event,-1);
      }
      else{
      	dd.mpanel.clear();
      }
      repaint();
      afterEvent();
    }
  }

//--------------------------------------------------------------------//
  void afterEvent(){
// イベント後処理
    if(dd.event[event].type==ENCOUNT) mode=BATTLE;
    else mode=MOVE;
    panelMode=mode;
  }

//--------------------------------------------------------------------//
  void Attack(){
// 攻撃処理
    if(mode==BATTLE){
      dd.Attack();
      repaint();
      if(dd.currentEnemy==null){
      	mode=MOVE;
      	panelMode=MOVE;
      }
    }
  }

//--------------------------------------------------------------------//
  void Escape(){
// 逃走処理
    if(mode==BATTLE){
      dd.Escape();
      repaint();
      if(dd.currentEnemy==null){
      	mode=MOVE;
      	panelMode=MOVE;
      }
    }
  }

//--------------------------------------------------------------------//
  void Item(){
// アイテムリスト表示処理
    if(mode!=EVENT && dd.ipanel.itemNumber>0){
      panelMode=ITEM;
      repaint();
    }
  }

//--------------------------------------------------------------------//
  void Use(int index){
// アイテム使用処理
    if(panelMode==ITEM && index>=0){
      dd.useItem(index);
    }
    panelMode=mode;
    repaint();
  }

//--------------------------------------------------------------------//
  void Drop(int index){
// アイテム廃棄処理
    if(panelMode==ITEM && index>=0){
      dd.dropItem(index);
    }
    panelMode=mode;
    repaint();
  }

//--------------------------------------------------------------------//
  public void update(Graphics g){
// 再表示
    if (dd!=null) {
      waitsw=true;
      paintMap(bg);
      g.drawImage(bgImage,0,0,this);
      waitsw=false;
    }
    else if(message!=null){
      drawError(g,message);
    }
  }

//--------------------------------------------------------------------//
  public void paint(Graphics g){
// 表示
    fx=getSize().width;
    fy=getSize().height;
    if(dd!=null){
      waitsw=true;
      setPaint();
      paintMap(bg);
      g.drawImage(bgImage,0,0,this);
      waitsw=false;
    }
    else if(message!=null){
      drawError(g,message);
    }
  }

//--------------------------------------------------------------------//
  void setPaint(){
// 表示部分設定
    DungeonMessagePanel mpanel;
    ItemListPanel ipanel;

    bgImage=createImage(fx,fy);
    bg=bgImage.getGraphics();
    x0=dd.textWidth(bg,fontsize2,16)+2;
    y0=dd.titleHeight(bg,fontsize1)+2;
    fxi=fx-2*x0-5;
    fyi=2*fy/3-y0-5;
    esize=(int)(0.8*Math.min(fxi,fyi));
    x1=x0+(fxi-esize)/2;
    y1=y0+(fyi-esize)/2;
    spanel=new StatusPanel(fontsize2,0,y0,x0-5,fyi,backColor,textColor);
    mpanel=new DungeonMessagePanel(bg,fontsize2,0,2*fy/3,fx-x0-5,fy/3
      	      	      	      	  ,backColor,textColor);
    ipanel=new ItemListPanel(bg,fontsize2,x0+5,fy/3,fx-2*x0-10,fy/3-5
      	      	      	    ,backColor,textColor);
    dd.setMIPanel(mpanel,ipanel);
    if(dd.event[event].type==START) dd.drawMessage(event);
    fxi=fx-x0-5;
    fyi=fy-y0-5;
    dd.set3DMesh(fxi,fyi,depth);
    dd.set2DMesh(fxi,fyi);
    setControlPanel();
  }

//--------------------------------------------------------------------//
  void setControlPanel(){
// コントロールパネル設定
    int dx=x0/2-1,dy=fy/10-1,sy0,cx0,cy0,cx1,cx2,dx2,dy2;

    cx0=fx-x0;
    cy0=y0;
    cx1=cx0+x0/4;
    cx2=x0+(fx-2*x0)/6;
    dx2=(fx-2*x0)/3;
    dy2=fy/10;
    forward=new ControlButton(PANELBUTTON[0],cx1,cy0,dx,dy);
    cy0+=dy;
    left=new ControlButton(PANELBUTTON[1],cx0,cy0,dx,dy);
    right=new ControlButton(PANELBUTTON[2],cx0+dx,cy0,dx,dy);
    cy0+=dy;
    back=new ControlButton(PANELBUTTON[3],cx1,cy0,dx,dy);
    cy0+=dy;
    yes=new ControlButton(PANELBUTTON[4],cx2,cy0,dx2,dy2);
    no=new ControlButton(PANELBUTTON[5],cx2+dx2,cy0,dx2,dy2);
    viewsw=new ControlButton(PANELBUTTON[6],cx1,cy0,dx,dy);
    cy0+=dy;
    attack=new ControlButton(PANELBUTTON[7],cx1,cy0,dx,dy);
    cy0+=dy;
    escape=new ControlButton(PANELBUTTON[8],cx1,cy0,dx,dy);
    cy0+=dy;
    item=new ControlButton(PANELBUTTON[9],cx1,cy0,dx,dy);
    cy0+=dy;
    use=new ControlButton(PANELBUTTON[10],cx1,cy0,dx,dy);
    cy0+=dy;
    drop=new ControlButton(PANELBUTTON[11],cx1,cy0,dx,dy);
  }

//--------------------------------------------------------------------//
  void paintMap(Graphics g){
// マップ描画
    int fx2,fy2;

    g.setColor(backColor);
    g.fillRect(0,0,fx,fy);
    dd.drawTitle(g,dd.flr[dd.mg[dd.pp].floor].floorColor
      	      	,dd.flr[dd.mg[dd.pp].floor].wallColor,fx,fontsize1);
    if(mapView==VIEW3D){
      dd.draw3DMap(g,0,y0,fxi,fyi,depth);
      dd.mpanel.draw(g);
      spanel.draw(g,dd.player);
    }
    else{
      dd.draw2DMap(g,0,y0);
    }
    switch(panelMode){
      case BATTLE:
      	g.drawImage(dd.imagedata.partImage[dd.currentEnemy.image],x1,y1
      	      	   ,esize,esize,this);
      	drawBattlePanel(g);
      	break;
      case YESNO:
      	drawYesNoPanel(g);
      	break;
      case ELEVATOR:
      	fx2=fx-2*x0-5;
      	fy2=2*fy/3-y0-5;
      	if(setElevator)
      	  setElevatorPanel(g,event,x0,y0,fx2,fy2,fontsize1);
      	drawElevator(g,event,fontsize1,backColor,textColor);
      	break;
      case MOVE:
      	drawMovePanel(g);
      	break;
      case ITEM:
      	drawItemPanel(g);
      	break;
    }
    ButtonRelease();
  }

//--------------------------------------------------------------------//
  void drawMovePanel(Graphics g){
// 移動用パネル表示
    Font font=new Font("Serif",Font.PLAIN,fontsize2);
    g.setFont(font);
    forward.draw(g,backColor,textColor);
    left.draw(g,backColor,textColor);
    right.draw(g,backColor,textColor);
    back.draw(g,backColor,textColor);
    viewsw.draw(g,backColor,textColor);
    item.draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawBattlePanel(Graphics g){
// 戦闘用パネル表示
    Font font=new Font("Serif",Font.PLAIN,fontsize2);
    g.setFont(font);
    attack.draw(g,backColor,textColor);
    escape.draw(g,backColor,textColor);
    item.draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawYesNoPanel(Graphics g){
// Yes/No選択表示
    Font font=new Font("Serif",Font.PLAIN,fontsize2);
    g.setFont(font);
    yes.draw(g,backColor,textColor);
    no.draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void drawItemPanel(Graphics g){
// アイテム用パネル表示
    Font font=new Font("Serif",Font.PLAIN,fontsize2);
    dd.ipanel.draw(g);
    g.setFont(font);
    use.draw(g,backColor,textColor);
    drop.draw(g,backColor,textColor);
  }

//--------------------------------------------------------------------//
  void setElevatorPanel(Graphics g,int ev,int x0,int y0,int fx,int fy
      	      	       ,int fontsize){
// エレベーター階層表示設定
    int i,flr,sx,sy,dx,dy,nx,ny;
    Font font=new Font("Serif",Font.PLAIN,fontsize);
    String message="";

    g.setFont(font);
    FontMetrics fm=g.getFontMetrics();
    dx=dd.textWidth(g,fontsize,5)+2;
    dy=fm.getHeight()+2;
    nx=fx/dx;
    ny=fy/dy;
    sx=x0+(fx-dx)/2;
    sy=y0+dy;

    for(i=0;i<dd.elev[dd.event[ev].move].nfloor;i++){
      flr=dd.elev[dd.event[ev].move].floor[i];
      if(flr>=0) message=""+flr+"F";
      else message="B"+(-flr)+"F";
      sx=x0+dx/2+(i/ny)*dx;
      sy=y0+(i%ny+1)*dy;
      elevator[i]=new ControlButton(message,sx,sy,dx,dy);
    }
    setElevator=false;
  }

//--------------------------------------------------------------------//
  void drawElevator(Graphics g,int ev,int fontsize
      	      	   ,Color backColor,Color textColor){
// エレベーター階層表示
    int i;
    Font font=new Font("Serif",Font.PLAIN,fontsize);
    g.setFont(font);
    for(i=0;i<dd.elev[dd.event[ev].move].nfloor;i++){
      elevator[i].draw(g,backColor,textColor);
    }
  }

//--------------------------------------------------------------------//
  void ButtonRelease(){
// ボタン離し
    forward.Release();
    right.Release();
    left.Release();
    back.Release();
    viewsw.Release();
    yes.Release();
    no.Release();
    attack.Release();
    escape.Release();
    item.Release();
    use.Release();
    drop.Release();
  }

//--------------------------------------------------------------------//
  void drawError(Graphics g,String message){
// エラーメッセージ表示
    int sx,sy;
    Font font=new Font("Serif",Font.PLAIN,fontsize2);
    g.setFont(font);
    FontMetrics fm=g.getFontMetrics();
    sx=fm.stringWidth(message);
    sy=fm.getHeight();
    g.setColor(textColor);
    g.drawString(message,(fx-sx)/2,(fy+sy)/2);
  }
}

//--------------------------------------------------------------------//
// ボタンクラス
class ControlButton{
  private String label; // ボタンラベル
  private int x0,y0;    // 基準位置
  private int x,y;      // ボタン大きさ
  private 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 StatusPanel implements Message{
  private int fontsize;                   // 文字フォントの大きさ
  private int x0,y0;                      // 基準位置
  private int x,y;                        // 表示範囲
  private Color backColor,textColor;      // 背景色・文字色
  private int sx0,sy0,dy;

//--------------------------------------------------------------------//
  StatusPanel(int fontsize,int x0,int y0,int x,int y
      	     ,Color backColor,Color textColor){
    this.fontsize=fontsize;
    this.x0=x0;
    this.y0=y0;
    this.x=x;
    this.y=y;
    this.backColor=backColor;
    this.textColor=textColor;
    dy=y/8;
    sx0=x0+5;
    sy0=y0+y/10;
  }

//--------------------------------------------------------------------//
  void draw(Graphics g,Player player){
// ステータス表示
    int i,sy1=sy0;

    Font font=new Font("Serif",Font.PLAIN,fontsize);
    g.setFont(font);
    g.setColor(backColor);
    g.fillRect(x0,y0,x,y);
    g.setColor(textColor);
    g.drawRect(x0,y0,x,y);
    g.drawString(player.name,sx0,sy1);
    sy1+=dy;
    g.drawString(PLAYERPARAM[0]+player.level,sx0,sy1);
    sy1+=dy;
    g.drawString(PLAYERPARAM[1]+player.hp+SLASH+player.maxhp,sx0,sy1);
    sy1+=dy;
    g.drawString(PLAYERPARAM[2]+player.attack,sx0,sy1);
    sy1+=dy;
    g.drawString(PLAYERPARAM[3]+player.defence,sx0,sy1);
    sy1+=dy;
    g.drawString(PLAYERPARAM[4]+player.experience+SLASH+player.nextExp,sx0,sy1);
    sy1+=dy;
    if(player.weapon==null) g.drawString(WEAPON,sx0,sy1);
    else g.drawString(WEAPON+player.weapon.name,sx0,sy1);
    sy1+=dy;
    if(player.defend==null) g.drawString(DEFEND,sx0,sy1);
    else g.drawString(DEFEND+player.defend.name,sx0,sy1);
  }
}

//--------------------------------------------------------------------//
// メッセージパネル
class DungeonMessagePanel implements Parameters{
  private int fontsize;                     // 文字フォントの大きさ
  private int x0,y0;                        // 基準位置
  private int x,y;                          // 表示範囲
  private Color backColor,textColor;        // 背景色・文字色
  private String line[]=new String[MESSAGELINE];   // メッセージ文
  private int lineNumber=0;                 // メッセージ行数
  private int sy,nline=0;

//--------------------------------------------------------------------//
  DungeonMessagePanel(Graphics g,int fontsize,int x0,int y0,int x,int y
      	      	     ,Color backColor,Color textColor){
    this.fontsize=fontsize;
    this.x0=x0;
    this.y0=y0;
    this.x=x;
    this.y=y;
    this.backColor=backColor;
    this.textColor=textColor;
    Font font=new Font("Serif",Font.PLAIN,fontsize);
    g.setFont(font);
    FontMetrics fm=g.getFontMetrics();
    sy=fm.getHeight()+2;
    nline=Math.min(y/sy,MESSAGELINE);
  }

//--------------------------------------------------------------------//
  void write(String string){
// メッセージ書き込み
    int i,dl;
    if(lineNumber>=nline){
      dl=1+lineNumber-nline;
      for(i=dl;i<nline;i++){
      	line[i-dl]=line[i];
      }
      line[nline-1]=string;
    }
    else{
      line[lineNumber]=string;
      lineNumber++;
    }
  }

//--------------------------------------------------------------------//
  void draw(Graphics g){
// メッセージ表示
    int i;
    Font font=new Font("Serif",Font.PLAIN,fontsize);

    if(lineNumber>0){
      g.setFont(font);
      g.setColor(backColor);
      g.fillRect(x0,y0,x,y);
      g.setColor(textColor);
      g.drawRect(x0,y0,x,y);
      for(i=0;i<lineNumber;i++){
      	g.drawString(line[i],x0,y0+(i+1)*sy);
      }
    }
  }

//--------------------------------------------------------------------//
  void clear(){
// メッセージ消去
    lineNumber=0;
  }
}

//--------------------------------------------------------------------//
// アイテムリストパネル
class ItemListPanel implements Parameters{
  private static final int NAME=14;     // アイテム名文字数の上限

  private int fontsize;                 // 文字フォントの大きさ
  private int x0,y0;                    // 基準位置
  private int x,y;                      // 表示範囲
  private Color backColor,textColor;    // 背景色・文字色
  Item item[]=new Item[ITEMMAX];        // リスト内アイテム
  int itemNumber=0;                     // リスト内アイテム数
  int itemNumberMax=0;                  // リスト内アイテム数上限
  int index=NOSELECT;
  private int sx,sy,nx=0,ny=0;

//--------------------------------------------------------------------//
  ItemListPanel(Graphics g,int fontsize,int x0,int y0,int x,int y
      	       ,Color backColor,Color textColor){
    this.fontsize=fontsize;
    this.x0=x0;
    this.y0=y0;
    this.x=x;
    this.y=y;
    this.backColor=backColor;
    this.textColor=textColor;
    Font font=new Font("Serif",Font.PLAIN,fontsize);
    g.setFont(font);
    FontMetrics fm=g.getFontMetrics();
    sx=NAME*fm.stringWidth("A");
    sy=fm.getHeight()+2;
    nx=Math.min(x/sx,ITEMMAX);
    ny=Math.min(y/sy,ITEMMAX);
    itemNumberMax=Math.min(nx*ny,ITEMMAX);
  }

//--------------------------------------------------------------------//
  void draw(Graphics g){
// アイテムリスト表示
    int i;
    Font font=new Font("Serif",Font.PLAIN,fontsize);

    if(itemNumber>0){
      g.setFont(font);
      g.setColor(backColor);
      g.fillRect(x0,y0,x,y);
      g.setColor(textColor);
      g.drawRect(x0,y0,x,y);
      if(index>=0) g.drawRect(x0+(index/ny)*sx,y0+(index%ny)*sy,sx,sy);
      for(i=0;i<itemNumber;i++){
      	g.drawString(item[i].name,x0+4+(i/ny)*sx,y0-1+(i%ny+1)*sy);
      }
    }
  }

//--------------------------------------------------------------------//
  void add(Item newItem){
// アイテム追加
    if(itemNumber<itemNumberMax){
      item[itemNumber]=newItem;
      itemNumber++;
    }
  }

//--------------------------------------------------------------------//
  void delete(int index){
// アイテム削除
    int i;

    if(itemNumber>=index){
      itemNumber--;
      for(i=index;i<itemNumber;i++){
      	item[i]=item[i+1];
      }
      item[itemNumber]=null;
      this.index=NOSELECT;
    }
  }

//--------------------------------------------------------------------//
  int selected(int px,int py){
// 選択されたアイテムリスト番号
    int i;
    for(i=0;i<itemNumber;i++){
      if(x0+(i/ny)*sx<=px && px<=x0+(i/ny+1)*sx){
      	if(y0+(i%ny)*sy<=py && py<=y0+(i%ny+1)*sy){
      	  index=i;
      	  return index;
      	}
      }
    }
    return NOSELECT;
  }

//--------------------------------------------------------------------//
  void upperIndex(){
// アイテムリスト選択
    switch(index){
      default:
      	index--;
      	break;
      case NOSELECT:
      	index=0;
      	break;
      case 0:
      	break;
    }
  }

//--------------------------------------------------------------------//
  void lowerIndex(){
// アイテムリスト選択
    if(index==NOSELECT) index=itemNumber-1;
    else if(index!=itemNumber-1) index++;
  }

//--------------------------------------------------------------------//
  void Cancel(){
// アイテムリスト選択キャンセル
    index=NOSELECT;
  }
}

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

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

  ImageData(Image baseImage,int partsize){
    this.baseImage=baseImage;
    this.partsize=partsize;
    nx=baseImage.getWidth(this)/partsize;
    ny=baseImage.getHeight(this)/partsize;
    num=Math.min(nx*ny,NMAX);
    this.baseImage=baseImage;
    makePartImage(baseImage);
  }

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

    for(i=0;i<num;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));
    }
  }
}

//--------------------------------------------------------------------//
// ダンジョンデータ
class DungeonData implements Parameters,Message{
  DungeonMessagePanel mpanel;
  ItemListPanel ipanel;
  draw2D d2d;                           // 2D表示クラス
  draw3D d3d;                           // 3D表示クラス
  ImageData imagedata;                  // 画像イメージデータクラス
  String title=null;                    // タイトル
  Floor flr[]=new Floor[FLOORMAX];      // 階層データ
  MapGrid mg[]=new MapGrid[WALLMAX];    // マップマス目データ
  int wall[]=new int[WALLMAX];          // 壁部分データの値
  int nfloor=0;                         // 階層数
  int partsize=100;                     // 部品イメージの大きさ
  int nkey=0;                           // 鍵の種類数
  int startPoint=0;                     // スタート地点
  int pp=0,direc=NORTH;                 // 現在の位置・方角
  MonsterMap mmap[]=new MonsterMap[FLOORMAX];   // ワンダリングモンスター分布クラス
  KeyDoor kd[]=new KeyDoor[EVENTMAX];   // 鍵付き扉クラス
  Event event[]=new Event[EVENTMAX];    // イベントクラス
  Elevator elev[]=new Elevator[FLOORMAX];       // エレベータークラス
  Item item[]=new Item[ITEMMAX];        // アイテムクラス
  int keyNumber[]=new int[ITEMMAX];     // 鍵番号
  Player player;                        // プレイヤー
  Monster currentEnemy;                 // 現在の敵キャラクター
  Monster monster[]=new Monster[MONSTERMAX];    // モンスタークラス
  Random random=new Random();

  DungeonData(InputStream is,Image image) throws IOException{
    readGlobalData(is);
    imagedata=new ImageData(image,partsize);
  }

//--------------------------------------------------------------------//
  void setMIPanel(DungeonMessagePanel mpanel,ItemListPanel ipanel){
// メッセージ表示部分・アイテムリストの設定
    this.mpanel=mpanel;
    this.ipanel=ipanel;
  }

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

    st.eolIsSignificant(true);
    readHeadData(st);
    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("Floor")){             // 階層データ
      	    readFloorData(st);
      	  }
      	  else if(st.sval.equals("MonsterMap")){   // ワンダリングモンスター分布データ
      	    readMonsterMapData(st);
      	  }
      	  else if(st.sval.equals("KeyDoor")){      // 鍵付き扉データ
      	    readKeyDoorData(st);
      	  }
      	  else if(st.sval.equals("Event")){        // イベントデータ
      	    readEventData(st);
      	  }
      	  else if(st.sval.equals("Item")){         // アイテムデータ
      	    readItemData(st);
      	  }
      	  else if(st.sval.equals("Player")){       // プレイヤーデータ
      	    readPlayerData(st);
      	  }
      	  else if(st.sval.equals("Monster")){      // モンスターデータ
      	    readMonsterData(st);
      	  }
      	  break;
      }
    }
    is.close();
  }

//--------------------------------------------------------------------//
  void readHeadData(StreamTokenizer st) throws IOException{
// ヘッドデータ読み込み
    if(st.nextToken()==StreamTokenizer.TT_WORD){
      title=st.sval;
    }
    while(st.nextToken()!=StreamTokenizer.TT_NUMBER);
      partsize=(int)st.nval;
  }

//--------------------------------------------------------------------//
  void readFloorData(StreamTokenizer st) throws IOException{
// 階層データ読み込み
    String ftitle=null,ftitle2=null;
    int i,j,ii=0,jj,jjmax;
    int array[]=new int[3];
    int flabel=0,n1=0,n2=0,sumf=0,ofsetw,ofsetf,x=0,y=0;
    Color ceilColor=null,floorColor=null,wallColor=null
      	 ,swallColor=null,doorColor=null;
    boolean EndOfPart;

    while(st.nextToken()!=StreamTokenizer.TT_NUMBER);
      nfloor=(int)st.nval;
    for(i=0;i<nfloor;i++){
      EndOfPart=false;
      ofsetw=ii;
      ofsetf=sumf;
      jj=0;
      while(st.nextToken()!=StreamTokenizer.TT_WORD);
      	ftitle2=st.sval;
      while(st.nextToken()!=StreamTokenizer.TT_NUMBER);
      	flabel=(int)st.nval;
      if(flabel>=0){
      	ftitle="  "+flabel+"F";
      }
      else{
      	ftitle="  B"+(-flabel)+"F";
      }
      if(ftitle2.equals("null")){}
      else{
      	ftitle+="  "+ftitle2;
      }
      readIntNumbers(st,array,2);
      n1=array[0];
      n2=array[1];
      jjmax=2*n1*n2+n1+n2;
      sumf+=n1*n2;
      for(j=ofsetf;j<sumf;j++){
      	x=(j-ofsetf)%n1;
      	y=(j-ofsetf)/n1;
      	mg[j]=new MapGrid(x,y,i,ofsetw,n1);
      }

      while(!EndOfPart){
      	switch (st.nextToken()){
      	  default:
      	    EndOfPart=true;
      	    break;
      	  case StreamTokenizer.TT_EOL:
      	    break;
      	  case StreamTokenizer.TT_NUMBER:
      	    wall[ii]=(int)st.nval;
      	    ii++;
      	    jj++;
      	    if(jj==jjmax) EndOfPart=true;
      	    break;
      	  case StreamTokenizer.TT_WORD:
      	    if(st.sval.equals("ceil")){                       // 天井表示色
      	      readIntNumbers(st,array,3);
      	      ceilColor=new Color(array[0],array[1],array[2]);
      	    }
      	    else if(st.sval.equals("floor")){                 // 床表示色
      	      readIntNumbers(st,array,3);
      	      floorColor=new Color(array[0],array[1],array[2]);
      	    }
      	    else if(st.sval.equals("wall")){                  // 壁表示色
      	      readIntNumbers(st,array,3);
      	      wallColor=new Color(array[0],array[1],array[2]);
      	      swallColor=new Color(array[0]/2,array[1]/2,array[2]/2);
      	    }
      	    else if(st.sval.equals("door")){                  // 扉表示色
      	      readIntNumbers(st,array,3);
      	      doorColor=new Color(array[0],array[1],array[2]);
      	    }
      	    break;
      	}
      }
      flr[i]=new Floor(ftitle,flabel,ceilColor,floorColor,wallColor
      	      	      ,swallColor,doorColor,n1,n2,ofsetw,ofsetf);
    }
  }

//--------------------------------------------------------------------//
  void readMonsterMapData(StreamTokenizer st) throws IOException{
// ワンダリングモンスター分布データ
    int i,j,floor,nom,mm=0,n1=0,n2=0;
    int array[]=new int[2*MONSTER1MAP];
    int monster[]=new int[MONSTER1MAP];
    double encount[]=new double[MONSTER1MAP];
    boolean EndOfPart=false;

    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("fullfloor")){                    // 階層全体
      	    readIntNumbers(st,array,2);
      	    floor=array[0];
      	    nom=array[1];
      	    readIntNumbers(st,array,2*nom);
      	    for(i=0;i<nom;i++){
      	      monster[i]=array[2*i];
      	      encount[i]=0.01*(double)array[2*i+1];
      	    }
      	    for(i=0;i<nfloor;i++){
      	      if(flr[i].floor==floor){
      	      	n1=flr[i].pointer(0,0);
      	      	n2=flr[i].pointer(flr[i].n1-1,flr[i].n2-1);
      	      }
      	    }
      	    for(i=n1;i<=n2;i++){
      	      mg[i].setMonsterMap(mm);
      	    }
      	    mmap[mm]=new MonsterMap(nom,monster,encount);
      	    mm++;
      	  }
      	  else if(st.sval.equals("end")){                     // 終了
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    EndOfPart=true;
      	  }
      }
    }
  }

//--------------------------------------------------------------------//
  void readKeyDoorData(StreamTokenizer st) throws IOException{
// 鍵付き扉データ読み込み
    int i;
    int array[]=new int[4];
    Color kdColor=null;

    while(st.nextToken()!=StreamTokenizer.TT_NUMBER);
    nkey=(int)st.nval;
    for(i=0;i<nkey;i++){
      readIntNumbers(st,array,4);
      kdColor=new Color(array[1],array[2],array[3]);
      kd[-array[0]]=new KeyDoor(-array[0],kdColor);
    }
  }

//--------------------------------------------------------------------//
  void readEventData(StreamTokenizer st) throws IOException{
// イベントデータ読み込み
    int i,ielev=0,pt1=0,pt2=0,nf=0,eventp=0,f1,f2;
    int array[]=new int[6];
    boolean EndOfPart=false;
    String message;
    String evMessage[]=new String[EVENTLINE];

    event[eventp]=new Event(NOEVENT,0,0,evMessage);
    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("start")){                        // スタート
      	    eventp++;
      	    readIntNumbers(st,array,4);
      	    pp=pointer(array[1],array[2],array[0]);
      	    startPoint=pp;
      	    pt2=array[3];
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    readMessages(st,pt2,evMessage);
      	    mg[pp].setEvent(eventp);
      	    mg[pp].Through();
      	    event[eventp]=new Event(START,0,pt2,evMessage);
      	  }
      	  else if(st.sval.equals("goal")){                    // ゴール
      	    eventp++;
      	    readIntNumbers(st,array,4);
      	    pt1=pointer(array[1],array[2],array[0]);
      	    pt2=array[3];
      	    mg[pt1].setEvent(eventp);
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    readMessages(st,pt2,evMessage);
      	    event[eventp]=new Event(GOAL,0,pt2,evMessage);
      	  }
      	  else if(st.sval.equals("stairs")){                  // 階段
      	    eventp+=2;
      	    readIntNumbers(st,array,6);
      	    f1=array[0];
      	    pt1=pointer(array[1],array[2],array[0]);
      	    f2=array[3];
      	    pt2=pointer(array[4],array[5],array[3]);
      	    mg[pt1].setEvent(eventp-1);
      	    mg[pt2].setEvent(eventp);
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    evMessage[0]=readMessage(st);
      	    if(f1>f2)
      	      event[eventp-1]=new Event(DOWNSTAIR,pt2,1,0,evMessage);
      	    else
      	      event[eventp-1]=new Event(UPSTAIR,pt2,1,0,evMessage);
      	    evMessage[0]=readMessage(st);
      	    if(f1>f2)
      	      event[eventp]=new Event(UPSTAIR,pt1,1,0,evMessage);
      	    else
      	      event[eventp]=new Event(DOWNSTAIR,pt1,1,0,evMessage);
      	  }
      	  else if(st.sval.equals("warp1way")){                // 片道ワープ
      	    eventp++;
      	    readIntNumbers(st,array,6);
      	    pt1=pointer(array[1],array[2],array[0]);
      	    pt2=pointer(array[4],array[5],array[3]);
      	    mg[pt1].setEvent(eventp);
      	    evMessage[0]=readMessage(st);
      	    event[eventp]=new Event(WARP1WAY,pt2,0,1,evMessage);
      	  }
      	  else if(st.sval.equals("warp2way")){                // 双方向ワープ
      	    eventp+=2;
      	    readIntNumbers(st,array,6);
      	    pt1=pointer(array[1],array[2],array[0]);
      	    pt2=pointer(array[4],array[5],array[3]);
      	    mg[pt1].setEvent(eventp-1);
      	    mg[pt2].setEvent(eventp);
      	    evMessage[0]=readMessage(st);
      	    event[eventp-1]=new Event(WARP2WAY,pt2,0,1,evMessage);
      	    event[eventp]=new Event(WARP2WAY,pt1,0,1,evMessage);
      	  }
      	  else if(st.sval.equals("elevator")){                // エレベーター
      	    if(st.nextToken()==StreamTokenizer.TT_NUMBER) nf=(int)st.nval;
      	    elev[ielev]=new Elevator(nf);
      	    evMessage[0]=readMessage(st);
      	    for(i=0;i<nf;i++){
      	      readIntNumbers(st,array,3);
      	      pt1=pointer(array[1],array[2],array[0]);
      	      eventp++;
      	      elev[ielev].setPoint(i,pt1,array[0],eventp);
      	      event[eventp]=new Event(ELEVATORIN,ielev,0,1,evMessage);
      	      mg[pt1].setEvent(eventp);
      	      while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    }
      	    ielev++;
      	  }
      	  else if(st.sval.equals("item")){                    // アイテム
      	    eventp++;
      	    readIntNumbers(st,array,4);
      	    pt2=array[0];
      	    pt1=pointer(array[2],array[3],array[1]);
      	    mg[pt1].setEvent(eventp);
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    evMessage[0]=readMessage(st);
      	    evMessage[1]=readMessage(st);
      	    event[eventp]=new Event(ITEMGET,pt2,1,1,evMessage);
      	  }
      	  else if(st.sval.equals("encount")){                 // 固定モンスター
      	    eventp++;
      	    readIntNumbers(st,array,4);
      	    pt2=array[0];
      	    pt1=pointer(array[2],array[3],array[1]);
      	    mg[pt1].setEvent(eventp);
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    evMessage[0]=readMessage(st);
      	    event[eventp]=new Event(ENCOUNT,pt2,0,1,evMessage);
      	  }
      	  else if(st.sval.equals("message")){                 // メッセージ
      	    eventp++;
      	    readIntNumbers(st,array,4);
      	    pt1=pointer(array[1],array[2],array[0]);
      	    pt2=array[3];
      	    mg[pt1].setEvent(eventp);
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    readMessages(st,pt2,evMessage);
      	    event[eventp]=new Event(MESSAGE,0,pt2,evMessage);
      	  }
      	  else if(st.sval.equals("heal")){                    // 回復ポイント
      	    eventp++;
      	    readIntNumbers(st,array,3);
      	    pt1=pointer(array[1],array[2],array[0]);
      	    mg[pt1].setEvent(eventp);
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    evMessage[0]=readMessage(st);
      	    evMessage[1]=readMessage(st);
      	    event[eventp]=new Event(HEAL,1,1,evMessage);
      	  }
      	  else if(st.sval.equals("end")){                     // 終了
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    EndOfPart=true;
      	  }
      }
    }
  }

//--------------------------------------------------------------------//
  void readItemData(StreamTokenizer st) throws IOException{
// アイテムデータ読み込み
    int ii,value;
    int array[]=new int[3];
    boolean EndOfPart=false,useable,dropable;
    String name;

    while(!EndOfPart){
      switch (st.nextToken()){
      	default:
      	  EndOfPart=true;
      	case StreamTokenizer.TT_EOL:
      	  break;
      	case StreamTokenizer.TT_NUMBER:
      	  ii=(int)st.nval;
      	  while(st.nextToken()!=StreamTokenizer.TT_WORD);
      	  if(st.sval.equals("key")){                          // 鍵
       	    readIntNumbers(st,array,3);
     	    value=-array[0];
      	    if(array[1]==0) useable=false;
      	    else useable=true;
      	    if(array[2]==0) dropable=false;
      	    else dropable=true;
      	    name=readMessage(st);
      	    item[ii]=new Item(ii,Item.KEY,value,name,useable,dropable);
      	    keyNumber[value]=ii;
      	  }
      	  else if(st.sval.equals("cure")){                    // 回復
       	    readIntNumbers(st,array,3);
     	    value=array[0];
      	    if(array[1]==0) useable=false;
      	    else useable=true;
      	    if(array[2]==0) dropable=false;
      	    else dropable=true;
      	    name=readMessage(st);
      	    item[ii]=new Item(ii,Item.CURE,value,name,useable,dropable);
      	  }
      	  else if(st.sval.equals("weapon")){                  // 武器
       	    readIntNumbers(st,array,3);
     	    value=array[0];
      	    if(array[1]==0) useable=false;
      	    else useable=true;
      	    if(array[2]==0) dropable=false;
      	    else dropable=true;
      	    name=readMessage(st);
      	    item[ii]=new Item(ii,Item.WEAPON,value,name,useable,dropable);
      	  }
      	  else if(st.sval.equals("defend")){                  // 防具
       	    readIntNumbers(st,array,3);
     	    value=array[0];
      	    if(array[1]==0) useable=false;
      	    else useable=true;
      	    if(array[2]==0) dropable=false;
      	    else dropable=true;
      	    name=readMessage(st);
      	    item[ii]=new Item(ii,Item.DEFEND,value,name,useable,dropable);
      	  }
      	  break;
      	case StreamTokenizer.TT_WORD:
      	  if(st.sval.equals("end")){                          // 終了
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    EndOfPart=true;
      	  }
      }
    }
  }

//--------------------------------------------------------------------//
  void readPlayerData(StreamTokenizer st) throws IOException{
// プレイヤーデータ読み込み
    int i,number,hp,at,df,wpn=0,dfd=0,exp,lvmax,lv;
    boolean EndOfPart=false;
    String name;
    int array[]=new int[5*Player.LVMAX];
    int dhp[]=new int[Player.LVMAX];
    int dat[]=new int[Player.LVMAX];
    int ddf[]=new int[Player.LVMAX];
    int dexp[]=new int[Player.LVMAX];

    while(!EndOfPart){
      switch (st.nextToken()) {
      	default:
      	  EndOfPart=true;
      	case StreamTokenizer.TT_EOL:
      	  break;
      	case StreamTokenizer.TT_WORD:
      	  name=st.sval;
      	  readIntNumbers(st,array,6);
      	  hp=array[0];
      	  at=array[1];
      	  df=array[2];
      	  wpn=array[3];
      	  dfd=array[4];
      	  lvmax=array[5];
      	  readIntNumbers(st,array,5*lvmax-5);
      	  dhp[0]=0;
      	  dat[0]=0;
      	  ddf[0]=0;
      	  dexp[0]=0;
      	  for(i=0;i<lvmax-1;i++){
      	    lv=array[5*i];
      	    dhp[lv-1]=array[5*i+1];
      	    dat[lv-1]=array[5*i+2];
      	    ddf[lv-1]=array[5*i+3];
      	    dexp[lv-1]=array[5*i+4];
      	  }
      	  player=new Player(name,hp,at,df,lvmax,dhp,dat,ddf,dexp);
      	  if(wpn>0) player.equip(item[wpn]);
      	  if(dfd>0) player.equip(item[dfd]);
      	  EndOfPart=true;
      }
    }
  }

//--------------------------------------------------------------------//
  void readMonsterData(StreamTokenizer st) throws IOException{
// モンスターデータ読み込み
    int i,j,number,image,hp,at,df,exp,itemNumber=0;
    boolean EndOfPart=false;
    String name;
    int array[]=new int[2*MONSTERITEM];
    int itemnum[]=new int[MONSTERITEM];
    double itemDrop[]=new double[MONSTERITEM];

    while(!EndOfPart){
      switch (st.nextToken()) {
      	default:
      	  EndOfPart=true;
      	case StreamTokenizer.TT_EOL:
      	  break;
      	case StreamTokenizer.TT_NUMBER:                       // モンスター
      	  number=(int)st.nval;
      	  while(st.nextToken()!=StreamTokenizer.TT_WORD);
      	    name=st.sval;
      	  readIntNumbers(st,array,6);
      	  image=array[0];
      	  hp=array[1];
      	  at=array[2];
      	  df=array[3];
      	  exp=array[4];
      	  itemNumber=array[5];
      	  readIntNumbers(st,array,2*itemNumber);
      	  for(i=0;i<itemNumber;i++){
      	    itemnum[i]=array[2*i];
      	    itemDrop[i]=0.01*(double)array[2*i+1];
      	  }
      	  monster[number]=new Monster(name,image,hp,at,df,exp,itemNumber
      	      	      	      	     ,itemnum,itemDrop);
      	  break;
      	case StreamTokenizer.TT_WORD:
      	  if(st.sval.equals("end")){                          // 終了
      	    while(st.nextToken()!=StreamTokenizer.TT_EOL);
      	    EndOfPart=true;
      	  }
      }
    }
  }

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

//--------------------------------------------------------------------//
  String readMessage(StreamTokenizer st) throws IOException{
// メッセージ読み込み
    String line="";
    boolean start=true;
    while(st.nextToken()!=StreamTokenizer.TT_EOL){
      if(!start) line=line+" ";
      else start=false;
      line=line+st.sval;
    }
    return line;
  }

//--------------------------------------------------------------------//
  void readMessages(StreamTokenizer st,int n,String message[])
    throws IOException{
// 複数行メッセージ読み込み
    int i;
    String line="";
    boolean start;
    for(i=0;i<n;i++){
      start=true;
      while(st.nextToken()!=StreamTokenizer.TT_EOL){
      	if(start){
      	  line=" ";
      	  start=false;
      	}
      	line=line+st.sval;
      }
      message[i]=line;
    }
  }

//--------------------------------------------------------------------//
  void set3DMesh(int fx,int fy,int depth){
// ３次元地図のマス目設定
    d3d=new draw3D(fx,fy,depth);
  }

//--------------------------------------------------------------------//
  void set2DMesh(int fx,int fy){
// 2Dメッシュサイズの設定
    int i;

    d2d=new draw2D();
    for(i=0;i<nfloor;i++){
      flr[i].setMeshSize(fx,fy);
    }
  }

//--------------------------------------------------------------------//
  int pointer(int x,int y,int z){
// 位置変換
    int i;

    for(i=0;i<nfloor;i++){
      if(flr[i].floor==z){
      	return flr[i].pointer(x-1,y-1);
      }
    }
    return 0;
  }

//--------------------------------------------------------------------//
  int goAhead(){
// 前に移動
    int nn1=flr[mg[pp].floor].n1,nn2=flr[mg[pp].floor].n2,monster,oldp;
    double rd=random.nextDouble();

    oldp=pp;
    switch(direc){
      case NORTH:                    // 北に移動
      	if(canThrough(wall[mg[pp].nw])){
      	  if(mg[pp].y==0)     pp+=nn1*(nn2-1);
      	  else                pp-=nn1;
      	}
      	break;
      case EAST:                     // 東に移動
      	if(canThrough(wall[mg[pp].ew])){
      	  if(mg[pp].x==nn1-1) pp-=nn1-1;
      	  else                pp++;
      	}
      	break;
      case SOUTH:                    // 南に移動
      	if(canThrough(wall[mg[pp].sw])){
      	  if(mg[pp].y==nn2-1) pp-=nn1*(nn2-1);
      	  else                pp+=nn1;
      	}
      	break;
      case WEST:                     // 西に移動
      	if(canThrough(wall[mg[pp].ww])){
      	  if(mg[pp].x==0)     pp+=nn1-1;
      	  else                pp--;
      	}
    }
    mg[pp].Through();
    mpanel.clear();

    if(event[mg[pp].event].type==NOEVENT && oldp!=pp){
      if(mg[pp].monster>=0){
      	monster=mmap[mg[pp].monster].EncountMonster(rd);
      	if(monster>=0) EncounterEnemy(monster);
      }
    }
    return mg[pp].event;
  }

//--------------------------------------------------------------------//
  void turnRight(){
// 右を向く
    direc=(direc+1)%4;
  }

//--------------------------------------------------------------------//
  void turnLeft(){
// 左を向く
    direc=(direc+3)%4;
  }

//--------------------------------------------------------------------//
  void turnBack(){
// 後を向く
    direc=(direc+2)%4;
  }

//--------------------------------------------------------------------//
  boolean canThrough(int wall){
// 通過可能判定
    int ii;
    boolean can=true;
    if(wall==WALL){
      can=false;
    }
    else if(wall<0){
      ii=keyNumber[-wall];
      if(item[ii].getNumber==0) can=false;
    }
    return can;
  }

//--------------------------------------------------------------------//
  void eventAction(int ev,int floor){
// イベント実行
    int pelev,i;

    mpanel.clear();
    switch(event[ev].type){
      default:
      	break;
// イベント無し
      case NOEVENT:
      	break;
// スタート
      case START:
      	mg[pp].setEvent(NOEVENT);
      	break;
// ゴール
      case GOAL:
      	break;
// 上り階段
      case UPSTAIR:
      	pp=event[mg[pp].event].move;
      	mg[pp].Through();
      	break;
// 下り階段
      case DOWNSTAIR:
      	pp=event[mg[pp].event].move;
      	mg[pp].Through();
      	break;
// 片道ワープ
      case WARP1WAY:
      	pp=event[mg[pp].event].move;
      	mg[pp].Through();
      	break;
// 双方向ワープ
      case WARP2WAY:
      	pp=event[mg[pp].event].move;
      	mg[pp].Through();
      	break;
// エレベーター
      case ELEVATORIN:
      	if(floor>=0){
      	  pelev=event[mg[pp].event].move;
      	  pp=elev[pelev].point[floor];
      	  mg[pp].Through();
      	}
      	break;
// アイテム獲得
      case ITEMGET:
      	getItem(event[mg[pp].event].move);
      	mg[pp].setEvent(NOEVENT);
      	break;
// 固定モンスター
      case ENCOUNT:
      	EncounterEnemy(event[mg[pp].event].move);
      	mg[pp].setEvent(NOEVENT);
      	break;
// メッセージ
      case MESSAGE:
      	break;
// 回復ポイント
      case HEAL:
      	player.Cure(player.maxhp);
      	break;
    }
    if(event[ev].line2==0){
      mpanel.clear();
    }
    else if(event[ev].line1!=0){
      for(i=event[ev].line1;i<event[ev].line1+event[ev].line2;i++){
      	mpanel.write(event[ev].message[i]);
      }
    }
  }

//--------------------------------------------------------------------//
  void EncounterEnemy(int enemy){
// 敵と遭遇
    currentEnemy=new Monster(monster[enemy].name,monster[enemy].image
      	      	      	    ,monster[enemy].hp,monster[enemy].attack
      	      	      	    ,monster[enemy].defence,monster[enemy].experience
      	      	      	    ,monster[enemy].itemNumber,monster[enemy].item
      	      	      	    ,monster[enemy].ItemDrop);
    mpanel.clear();
    mpanel.write(currentEnemy.name+ENCOUNTMESSAGE);
  }

//--------------------------------------------------------------------//
  void Attack(){
// 攻撃処理
    int eDamage;
    boolean dead;
    double rd=random.nextDouble();

    rd=1.0+SIGMA*Math.asin(2.0*(rd-0.5));
    if(currentEnemy==null) return;
    eDamage=Math.max((int)(rd*player.attack+0.5)-currentEnemy.defence,0);
    dead=currentEnemy.Damage(eDamage);
    mpanel.write(player.name+ATTACKED);
    mpanel.write(currentEnemy.name+NI+eDamage+MONSTERDAMAGE);
    if(dead){
      killEnemy();
    }
    else{
      enemyAttack();
    }
  }

//--------------------------------------------------------------------//
  void enemyAttack(){
// 敵の攻撃の処理
    int pDamage;
    boolean dead;
    double rd=random.nextDouble();

    rd=1.0+SIGMA*Math.asin(2.0*(rd-0.5));
    pDamage=Math.max((int)(rd*currentEnemy.attack+0.5)-player.defence,0);
    dead=player.Damage(pDamage);
    mpanel.write(currentEnemy.name+ATTACKED);
    mpanel.write(player.name+HA+pDamage+PLAYERDAMAGE);
    if(dead){
      PlayerDead();
    }
  }

//--------------------------------------------------------------------//
  void Escape(){
// 逃走処理
    double rd=random.nextDouble();

    if(currentEnemy==null) return;
    mpanel.write(player.name+ESCAPEMESSAGE);
    if(rd<0.8){                               // 逃走成功
      mpanel.write(ESCAPEOKMESSAGE);
      currentEnemy=null;
    }
    else{                                     // 逃走失敗
      mpanel.write(ESCAPENGMESSAGE);
      enemyAttack();
    }
  }

//--------------------------------------------------------------------//
  void killEnemy(){
// 敵を倒したときの処理
    int getexp,getitem;
    double rd=random.nextDouble();
    boolean levelUp;

    mpanel.write(currentEnemy.name+WINMESSAGE);
    getexp=currentEnemy.experience;
    getitem=currentEnemy.dropItem(rd);
    if(getexp>0){
      mpanel.write(EXP+getexp+POINTGETMESSAGE);
      levelUp=player.getExp(getexp);
      if(levelUp){
      	mpanel.write(player.name+LVUPMESSAGE);
      	mpanel.write(MAXHP+player.dhp[player.level-1]
      	      	    +POINTUPMESSAGE);
      	mpanel.write(ATTACKP+player.dattack[player.level-1]
      	      	    +POINTUPMESSAGE);
      	mpanel.write(DEFENCEP+player.ddefence[player.level-1]
      	      	    +POINTUPMESSAGE);
      }
    }
    if(getitem>=0){
      getItem(getitem);
      if(ipanel.itemNumber<=ipanel.itemNumberMax)
      	mpanel.write(item[getitem].name+GETMESSAGE);
    }
    currentEnemy=null;
  }

//--------------------------------------------------------------------//
  void PlayerDead(){
// プレイヤーが死亡したときの処理
    mpanel.write(player.name+DEADMESSAGE);
    pp=startPoint;
    direc=NORTH;
    currentEnemy=null;
    player.Cure(player.maxhp);
  }

//--------------------------------------------------------------------//
  void getItem(int itemNumber){
// アイテム獲得
    if(ipanel.itemNumber<ipanel.itemNumberMax){
      item[itemNumber].getItem();
      ipanel.add(item[itemNumber]);
    }
  }

//--------------------------------------------------------------------//
  void useItem(int index){
// アイテム使用
    int use=ipanel.item[index].number,dhp;
    if(item[use].use){
      switch (item[use].type){
      	default:
      	case Item.CURE:
      	  item[use].useItem();
      	  mpanel.write(item[use].name+USEMESSAGE);
      	  dhp=player.Cure(item[use].value);
      	  mpanel.write("HP"+dhp+CUREMESSAGE);
      	  break;
      	case Item.WEAPON:
      	  if(player.weapon!=null) getItem(player.weapon.number);
      	  item[use].useItem();
      	  player.equip(item[use]);
      	  mpanel.write(item[use].name+EQUIPMESSAGE);
      	  break;
      	case Item.DEFEND:
      	  if(player.defend!=null) getItem(player.defend.number);
      	  item[use].useItem();
      	  player.equip(item[use]);
      	  mpanel.write(item[use].name+EQUIPMESSAGE);
      	  break;
      }
      ipanel.delete(index);
      if(currentEnemy!=null){
      	enemyAttack();
      }
    }
    else{
      mpanel.write(item[use].name+NOUSEMESSAGE);
    }
  }

//--------------------------------------------------------------------//
  void dropItem(int index){
// アイテムを捨てる
    int drop=ipanel.item[index].number;
    if(item[drop].drop){
      mpanel.write(item[drop].name+DROPMESSAGE);
      item[drop].loseItem();
      ipanel.delete(index);
      if(currentEnemy!=null){
      	enemyAttack();
      }
    }
    else{
      mpanel.write(item[drop].name+NODROPMESSAGE);
    }
  }

//--------------------------------------------------------------------//
  int textWidth(Graphics g,int fontsize,int width){
// 文字表示部分幅
    String titlebar=null;
    int sx,sy;
    Font font=new Font("Serif",Font.BOLD,fontsize);

// フォント設定
    g.setFont(font);
    FontMetrics fm=g.getFontMetrics();
    sx=width*fm.stringWidth("A");
    sy=fm.getHeight();

    return sx+4;
  }

//--------------------------------------------------------------------//
  int titleHeight(Graphics g,int fontsize){
// マップタイトル文字高さ
    int sy,gy=2;
    Font font=new Font("Serif",Font.BOLD,fontsize);

// フォント設定
    g.setFont(font);
    FontMetrics fm=g.getFontMetrics();
    sy=fm.getHeight();

    return gy+sy+4;
  }

//--------------------------------------------------------------------//
  void drawTitle(Graphics g,Color boadColor,Color textColor,int fx
      	      	,int fontsize){
// マップタイトル表示
    String titlebar=null;
    int sx,sy,gx,gy=2;
    Font font=new Font("Serif",Font.BOLD,fontsize);

    if(title.equals("null")){
      titlebar=null;
    }
    else{
      titlebar=title+"";
    }
    if(flr[mg[pp].floor].title.equals("null")){}
    else{
      titlebar+="  "+flr[mg[pp].floor].title;
    }
    switch(direc){
      case NORTH:                       // 北向き
      	titlebar+="  N";
      	break;
      case EAST:                        // 東向き
      	titlebar+="  E";
      	break;
      case SOUTH:                       // 南向き
      	titlebar+="  S";
      	break;
      case WEST:                        // 西向き
      	titlebar+="  W";
    }

// フォント設定
    g.setFont(font);
    FontMetrics fm=g.getFontMetrics();
    sx=fm.stringWidth(titlebar);
    sy=fm.getHeight();
    gx=(fx-sx)/2-5;

// 文字背景・文字表示
    g.setColor(boadColor);
    g.fillRect(gx,gy,sx+10,sy+4);
    g.setColor(textColor);
    g.drawString(titlebar,gx+5,gy+sy);
  }

//--------------------------------------------------------------------//
  void draw3DMap(Graphics g,int x0,int y0,int fx,int fy,int depth){
// ３次元地図表示
    int i,j,kk,kk2;
    int ww[]=new int[4];
    Color lineColor=flr[mg[pp].floor].floorColor;

    depth=Math.min(depth,DEPTH-2);
    d3d.init3DMap(g,x0,y0,depth,flr[mg[pp].floor].ceilColor
      	      	 ,flr[mg[pp].floor].floorColor);
    for(i=depth;i>0;i--){
      for(j=-d3d.nw[i];j<=0;j++){
      	kk=viewPointer(i-1,j);
      	kk2=viewPointer(i-1,-j);
      	switch(direc){
      	  case NORTH:
      	    ww[0]=wall[mg[kk].nw];
      	    ww[1]=wall[mg[kk2].nw];
      	    ww[2]=wall[mg[kk].ww];
      	    ww[3]=wall[mg[kk2].ew];
      	    break;
      	  case EAST:
      	    ww[0]=wall[mg[kk].ew];
      	    ww[1]=wall[mg[kk2].ew];
      	    ww[2]=wall[mg[kk].nw];
      	    ww[3]=wall[mg[kk2].sw];
      	    break;
      	  case SOUTH:
      	    ww[0]=wall[mg[kk].sw];
      	    ww[1]=wall[mg[kk2].sw];
      	    ww[2]=wall[mg[kk].ew];
      	    ww[3]=wall[mg[kk2].ww];
      	    break;
      	  case WEST:
      	    ww[0]=wall[mg[kk].ww];
      	    ww[1]=wall[mg[kk2].ww];
      	    ww[2]=wall[mg[kk].sw];
      	    ww[3]=wall[mg[kk2].nw];
      	}
      	d3d.draw3DMap(g,x0,y0,i,j,lineColor,flr[mg[pp].floor].wallColor
      	      	     ,flr[mg[pp].floor].swallColor,flr[mg[pp].floor].doorColor
      	      	     ,ww,kd);
      }
    }
  }

//--------------------------------------------------------------------//
  int viewPointer(int depth,int side){
// 相対位置による指定
    int px=0,py=0;

    px=mg[pp].x;
    py=mg[pp].y;
    switch(direc){
      case NORTH:                       // 北向き
      	px+=side;
      	py-=depth;
      	break;
      case EAST:                        // 東向き
      	px+=depth;
      	py+=side;
      	break;
      case SOUTH:                       // 南向き
      	px-=side;
      	py+=depth;
      	break;
      case WEST:                        // 西向き
      	px-=depth;
      	py-=side;
    }
    if(px<0)                          px+=flr[mg[pp].floor].n1;
    else if(px>=flr[mg[pp].floor].n1) px-=flr[mg[pp].floor].n1;
    if(py<0)                          py+=flr[mg[pp].floor].n2;
    else if(py>=flr[mg[pp].floor].n2) py-=flr[mg[pp].floor].n2;
    return flr[mg[pp].floor].pointer(px,py);
  }

//--------------------------------------------------------------------//
  void draw2DMap(Graphics g,int x0,int y0){
// ２次元地図表示
    int ks,ke,k,xx,yy;

    ks=flr[mg[pp].floor].ofsetf;
    ke=ks+flr[mg[pp].floor].n1*flr[mg[pp].floor].n2;
    for(k=ks;k<ke;k++){
      if(mg[k].through){
      	xx=x0+flr[mg[pp].floor].dmesh*mg[k].x;
      	yy=y0+flr[mg[pp].floor].dmesh*mg[k].y;
      	d2d.draw2DMesh(g,xx,yy,event,flr[mg[pp].floor],mg[k],wall,kd);
      }
    }
    xx=x0+flr[mg[pp].floor].dmesh*mg[pp].x;
    yy=y0+flr[mg[pp].floor].dmesh*mg[pp].y;
    d2d.drawMe2D(g,xx,yy,flr[mg[pp].floor],direc);
  }

//--------------------------------------------------------------------//
  void drawMessage(int ev){
// イベントメッセージ表示
    int i,is=0,ie=0,evtype=event[ev].type;

// フォント設定

// 文字背景・文字表示
    switch(MSSWITCH[evtype]){
      case NOSELECT:
      	is=event[ev].line1;
      	ie=event[ev].line1+event[ev].line2;
      	break;
      case SELECT:
      	is=0;
      	ie=event[ev].line1;
      	break;
      case EVSELECT:
      	is=event[ev].line1;
      	ie=event[ev].line1+event[ev].line2;
      	break;
    }
    for(i=is;i<ie;i++){
      mpanel.write(event[ev].message[i]);
    }
    if(event[ev].line1!=0){
      mpanel.write(YESNOSELECT);
    }
  }
}

//--------------------------------------------------------------------//
// 階層データ
class Floor{
  String title;       // 階層タイトル
  int floor;          // 階層ラベル
  Color ceilColor;    // 天井色
  Color floorColor;   // 床色
  Color wallColor;    // 壁色
  Color swallColor;   // 壁（横）色
  Color doorColor;    // 扉色
  int n1;             // 横のマス目の数
  int n2;             // 縦のマス目の数
  int dmesh;          // マス目の大きさ
  int ofsetw;         // データオフセット（壁）
  int ofsetf;         // データオフセット（床）

  Floor(String title,int floor,Color ceilColor,Color floorColor
       ,Color wallColor,Color swallColor,Color doorColor
       ,int n1,int n2,int ofsetw,int ofsetf){
    this.title=title;
    this.floor=floor;
    this.ceilColor=ceilColor;
    this.floorColor=floorColor;
    this.wallColor=wallColor;
    this.swallColor=swallColor;
    this.doorColor=doorColor;
    this.n1=n1;
    this.n2=n2;
    this.ofsetw=ofsetw;
    this.ofsetf=ofsetf;
  }

//--------------------------------------------------------------------//
  void setMeshSize(int fx,int fy){
// 表示サイズの設定
    dmesh=Math.min(fx/n1,fy/n2);
  }

//--------------------------------------------------------------------//
  int pointer(int x,int y){
// 位置ポインタ
    return ofsetf+n1*y+x;
  }
}

//--------------------------------------------------------------------//
// マップ１マスのデータ
class MapGrid{
  boolean through=false;    // 通過判定
  int x=0,y=0,floor=0;      // 座標位置
  int ew=0,ww=0,nw=0,sw=0;  // 東西南北の壁のポインタ
  int event=0;              // イベント
  int monster=-1;

  MapGrid(int x,int y,int floor){
    this.x=x;
    this.y=y;
    this.floor=floor;
  }

  MapGrid(int x,int y,int floor,int ofsetw,int n1){
    this(x,y,floor);
    nw=ofsetw+(2*n1+1)*y+x;
    ew=nw+n1+1;
    sw=nw+2*n1+1;
    ww=nw+n1;
  }

//--------------------------------------------------------------------//
  void Through(){
// ポイント通過
    through=true;
  }

//--------------------------------------------------------------------//
  void setEvent(int event){
// イベント設定
    this.event=event;
  }

//--------------------------------------------------------------------//
  void setMonsterMap(int monster){
// ワンダリングモンスター分布設定
    this.monster=monster;
  }
}

//--------------------------------------------------------------------//
// ワンダリングモンスター分布クラス
class MonsterMap implements Parameters{
  int number=0;                       // モンスター種類数
  int monster[]=new int[MONSTER1MAP];        // モンスター番号
  double encount[]=new double[MONSTER1MAP];  // モンスター遭遇確率

  MonsterMap(int number,int monster[],double encount[]){
    int i;
    this.number=number;
    for(i=0;i<number;i++){
      this.monster[i]=monster[i];
      this.encount[i]=encount[i];
    }
  }

//--------------------------------------------------------------------//
  int EncountMonster(double rdm){
// 遭遇するモンスター
    int i;
    double prob=0.0;
    for(i=0;i<number;i++){
      prob+=encount[i];
      if(rdm<prob){
      	return monster[i];
      }
    }
    return -1;
  }
}

//--------------------------------------------------------------------//
// 鍵付き扉クラス
class KeyDoor{
  int number=0;      // 鍵番号
  Color color;       // 扉表示色

  KeyDoor(int number,Color color){
    this.number=number;
    this.color=color;
  }
}

//--------------------------------------------------------------------//
// イベントクラス
class Event implements Parameters{
  int type=0;   // イベント種類
  int move=0;   // イベントによる移動位置
  int line1=0;  // 質問メッセージ行数
  int line2=0;  // 結果メッセージ行数
  String message[]=new String[EVENTLINE];   // イベントメッセージ

  Event(int type,int line1,int line2,String message[]){
    int i;
    this.type=type;
    this.line1=line1;
    this.line2=line2;
    for(i=0;i<line1+line2;i++){
      this.message[i]=message[i];
    }
  }

  Event(int type,int move,int line1,int line2,String message[]){
    this(type,line1,line2,message);
    this.move=move;
  }
}

//--------------------------------------------------------------------//
// エレベータークラス
class Elevator implements Parameters{
  int nfloor=0;              // 移動できるフロア数
  int point[]=new int[EVFLOORMAX]; // エレベーター位置
  int floor[]=new int[EVFLOORMAX]; // エレベーター階層
  int event[]=new int[EVFLOORMAX]; // エレベーターイベント番号

  Elevator(int nfloor){
    this.nfloor=Math.min(nfloor,EVFLOORMAX);
  }

//--------------------------------------------------------------------//
  void setPoint(int ii,int pt,int fl,int ev){
// 階層データ設定
    point[ii]=pt;
    floor[ii]=fl;
    event[ii]=ev;
  }
}

//--------------------------------------------------------------------//
// アイテムクラス
class Item implements Parameters{
  int number=0;      // アイテム番号
  int type=0;        // アイテム種類
  int value=0;       // アイテム特性値
  String name;       // アイテムの名前
  int getNumber=0;   // アイテムの獲得数
  boolean use;       // アイテム使用可能
  boolean drop;      // アイテム廃棄可能

  Item(int number,int type,int value,String name,boolean use,boolean drop){
    this.number=number;
    this.type=type;
    this.value=value;
    this.name=name;
    this.use=use;
    this.drop=drop;
  }

//--------------------------------------------------------------------//
  void useItem(){
// アイテム使用処理
    if(getNumber>0 && use) getNumber--;
  }

//--------------------------------------------------------------------//
  void getItem(){
// アイテム獲得処理
    getNumber++;
  }

//--------------------------------------------------------------------//
  void loseItem(){
// アイテム廃棄処理
    if(getNumber>0 && drop) getNumber--;
  }
}

//--------------------------------------------------------------------//
// キャラクタークラス
class Character implements Parameters{
  String name;       // キャラクターの名前
  int maxhp=0;       // キャラクターの最大生命力
  int hp=0;          // キャラクターの生命力
  int attack=0;      // キャラクターの攻撃力
  int defence=0;     // キャラクターの防御力
  int experience=0;  // キャラクターの経験値

  Character(String name,int hp,int attack,int defence){
    this.name=name;
    maxhp=hp;
    this.hp=hp;
    this.attack=attack;
    this.defence=defence;
  }
}

//--------------------------------------------------------------------//
// プレイヤークラス
class Player extends Character{
  Item weapon=null,defend=null;  // プレイヤーの武器・防具
  int level=1,levelMax=1;        // プレイヤーのレベル・最大値
  int nextExp=0;                 // 次のレベルの経験値
  int dhp[]=new int[LVMAX];      // レベルアップ時の上昇最大HP
  int dattack[]=new int[LVMAX];  // レベルアップ時の上昇攻撃力
  int ddefence[]=new int[LVMAX]; // レベルアップ時の上昇防御力
  int dexp[]=new int[LVMAX];     // レベルアップに必要な経験値

  Player(String name,int hp,int attack,int defence,int levelMax
      	,int dhp[],int dattack[],int ddefence[],int dexp[]){
    super(name,hp,attack,defence);
    int i;
    this.levelMax=levelMax;
    for(i=0;i<levelMax;i++){
      this.dhp[i]=dhp[i];
      this.dattack[i]=dattack[i];
      this.ddefence[i]=ddefence[i];
      this.dexp[i]=dexp[i];
    }
    nextExp=dexp[level];
  }

//--------------------------------------------------------------------//
  boolean Damage(int damage){
// ダメージを与える
    boolean dead=false;

    hp=Math.max(hp-damage,0);
    if(hp==0) dead=true;
    return dead;
  }

//--------------------------------------------------------------------//
  int Cure(int cure){
// ダメージを回復
    int dhp;
    dhp=Math.min(hp+cure,maxhp)-hp;
    hp+=dhp;
    return dhp;
  }

//--------------------------------------------------------------------//
  void equip(Item item){
// 装備する
    if(item.type==Item.WEAPON){
      if(weapon!=null) attack-=weapon.value;
      weapon=item;
      attack+=weapon.value;
    }
    else if(item.type==Item.DEFEND){
      if(defend!=null) defence-=defend.value;
      defend=item;
      defence+=defend.value;
    }
  }

//--------------------------------------------------------------------//
  boolean getExp(int exp){
// 経験値を獲得
    experience+=exp;
    if(experience>=nextExp && nextExp!=NOEXP){
      maxhp+=dhp[level];
      hp+=dhp[level];
      attack+=dattack[level];
      defence+=ddefence[level];
      level++;
      if(level==levelMax) nextExp=NOEXP;
      else nextExp=dexp[level];
      return true;
    }
    return false;
  }
}

//--------------------------------------------------------------------//
// モンスタークラス
class Monster extends Character{
  int image=0;                           // 部品イメージ番号
  int itemNumber=0;                      // 持っているアイテムの種類数
  int item[]=new int[MONSTERITEM];           // 持っているアイテム
  double ItemDrop[]=new double[MONSTERITEM]; // アイテムを落とす確率

  Monster(String name,int image,int hp,int attack,int defence,int experience
      	 ,int itemNumber,int item[],double ItemDrop[]){
    super(name,hp,attack,defence);
    int i;
    this.image=image;
    this.experience=experience;
    this.itemNumber=Math.min(itemNumber,MONSTERITEM);
    for(i=0;i<itemNumber;i++){
      this.item[i]=item[i];
      this.ItemDrop[i]=ItemDrop[i];
    }
  }

//--------------------------------------------------------------------//
  boolean Damage(int damage){
// ダメージを与える
    boolean dead=false;

    hp=Math.max(hp-damage,0);
    if(hp==0) dead=true;
    return dead;
  }

//--------------------------------------------------------------------//
  int Cure(int cure){
// ダメージを回復
    int dhp;
    dhp=Math.min(hp+cure,maxhp)-hp;
    hp+=dhp;
    return dhp;
  }

//--------------------------------------------------------------------//
  int dropItem(double rdm){
// 落とすアイテム
    int i;
    double drop=0.0;
    for(i=0;i<itemNumber;i++){
      drop+=ItemDrop[i];
      if(rdm<drop){
      	return item[i];
      }
    }
    return -1;
  }
}

//--------------------------------------------------------------------//
// ２次元マップ表示	
class draw2D implements Parameters{

  draw2D(){}

//--------------------------------------------------------------------//
  void draw2DMesh(Graphics g,int xx,int yy,Event event[],Floor flr
      	      	 ,MapGrid mg,int wall[],KeyDoor kd[]){
// ２次元地図１マス表示
    int em,sx,sy,fontsize=flr.dmesh-2;
    Font font=new Font("Serif",Font.PLAIN,fontsize);

// 床
    g.setColor(flr.floorColor);
    g.fillRect(xx,yy,flr.dmesh,flr.dmesh);
// 壁・扉
    if(wall[mg.nw]==WALL)      drawWall2D(g,xx,yy,0,flr);
    else if(wall[mg.nw]==DOOR) drawDoor2D(g,xx,yy,0,flr);
    else if(wall[mg.nw]<0)
      drawKeyDoor2D(g,xx,yy,0,flr,kd[-wall[mg.nw]].color);

    if(wall[mg.ww]==WALL)      drawWall2D(g,xx,yy,1,flr);
    else if(wall[mg.ww]==DOOR) drawDoor2D(g,xx,yy,1,flr);
    else if(wall[mg.ww]<0)
      drawKeyDoor2D(g,xx,yy,1,flr,kd[-wall[mg.ww]].color);

    if(wall[mg.ew]==WALL)      drawWall2D(g,xx+flr.dmesh,yy,1,flr);
    else if(wall[mg.ew]==DOOR) drawDoor2D(g,xx+flr.dmesh,yy,1,flr);
    else if(wall[mg.ew]<0)
      drawKeyDoor2D(g,xx+flr.dmesh,yy,1,flr,kd[-wall[mg.ew]].color);

    if(wall[mg.sw]==WALL)      drawWall2D(g,xx,yy+flr.dmesh,0,flr);
    else if(wall[mg.sw]==DOOR) drawDoor2D(g,xx,yy+flr.dmesh,0,flr);
    else if(wall[mg.sw]<0)
      drawKeyDoor2D(g,xx,yy+flr.dmesh,0,flr,kd[-wall[mg.sw]].color);

// イベント
    em=mg.event;
    if(em!=0){
      g.setColor(flr.wallColor);
      FontMetrics fm=g.getFontMetrics();
      sx=xx+(flr.dmesh-fm.stringWidth("A"))/2;
      sy=yy+(flr.dmesh+fm.getHeight())/2;
      switch(event[em].type){
// ゴール
      	case GOAL:
      	  g.drawString("G",sx,sy);
      	  break;
// 上り階段
      	case UPSTAIR:
      	  g.drawString("U",sx,sy);
      	  break;
// 下り階段
      	case DOWNSTAIR:
      	  g.drawString("D",sx,sy);
      	  break;
// 片道ワープ
      	case WARP1WAY:
      	  g.drawString("W",sx,sy);
      	  break;
// 双方向ワープ
      	case WARP2WAY:
      	  g.drawString("W",sx,sy);
      	  break;
// エレベーター
      	case ELEVATORIN:
      	  g.drawString("E",sx,sy);
      	  break;
      }
    }
  }

//--------------------------------------------------------------------//
  void drawWall2D(Graphics g,int x,int y,int hv,Floor flr){
// ２次元地図壁表示
    g.setColor(flr.wallColor);
    if(hv==0) g.drawLine(x,y,x+flr.dmesh,y);    // 南北
    else      g.drawLine(x,y,x,y+flr.dmesh);    // 東西
  }

//--------------------------------------------------------------------//
  void drawDoor2D(Graphics g,int x,int y,int hv,Floor flr){
// ２次元地図扉表示
    int dw,xx,yy;

    dw=flr.dmesh/4;
    g.setColor(flr.wallColor);
    if(hv==0){                                  // 南北
      g.drawLine(x,y,x+dw,y);
      g.drawLine(x+flr.dmesh-dw,y,x+flr.dmesh,y);
      g.setColor(flr.doorColor);
      g.drawLine(x+dw,y,x+flr.dmesh-dw,y);
    }
    else{                                       // 東西
      g.drawLine(x,y,x,y+dw);
      g.drawLine(x,y+flr.dmesh-dw,x,y+flr.dmesh);
      g.setColor(flr.doorColor);
      g.drawLine(x,y+dw,x,y+flr.dmesh-dw);
    }
  }

//--------------------------------------------------------------------//
  void drawKeyDoor2D(Graphics g,int x,int y,int hv,Floor flr
      	      	    ,Color kdoorColor){
// ２次元地図鍵付き扉表示
    int dw,xx,yy;

    dw=flr.dmesh/4;
    g.setColor(flr.wallColor);
    if(hv==0){                                  // 南北
      g.drawLine(x,y,x+dw,y);
      g.drawLine(x+flr.dmesh-dw,y,x+flr.dmesh,y);
      g.setColor(kdoorColor);
      g.drawLine(x+dw,y,x+flr.dmesh-dw,y);
    }
    else{                                       // 東西
      g.drawLine(x,y,x,y+dw);
      g.drawLine(x,y+flr.dmesh-dw,x,y+flr.dmesh);
      g.setColor(kdoorColor);
      g.drawLine(x,y+dw,x,y+flr.dmesh-dw);
    }
  }

//--------------------------------------------------------------------//
  void drawMe2D(Graphics g,int x0,int y0,Floor flr,int direc){
// ２次元地図自位置表示
    int k,dw1,dw2,dw3;
    int trix[]=new int[3];
    int triy[]=new int[3];

    for(k=0;k<3;k++){
      trix[k]=x0;
      triy[k]=y0;
    }
    dw1=flr.dmesh/4;
    dw2=flr.dmesh/2;
    dw3=flr.dmesh-dw1;
    g.setColor(flr.doorColor);
    switch(direc){
      case NORTH:                       // 北向き
      	trix[0]+=dw2; triy[0]+=dw1;
      	trix[1]+=dw1; triy[1]+=dw3;
      	trix[2]+=dw3; triy[2]+=dw3;
      	break;
      case EAST:                        // 東向き
      	trix[0]+=dw3; triy[0]+=dw2;
      	trix[1]+=dw1; triy[1]+=dw1;
      	trix[2]+=dw1; triy[2]+=dw3;
      	break;
      case SOUTH:                       // 南向き
      	trix[0]+=dw2; triy[0]+=dw3;
      	trix[1]+=dw1; triy[1]+=dw1;
      	trix[2]+=dw3; triy[2]+=dw1;
      	break;
      case WEST:                        // 西向き
      	trix[0]+=dw1; triy[0]+=dw2;
      	trix[1]+=dw3; triy[1]+=dw1;
      	trix[2]+=dw3; triy[2]+=dw3;
    }
    g.fillPolygon(trix,triy,3);
  }
}

//--------------------------------------------------------------------//
// ３次元マップ表示	
class draw3D implements Parameters{
  private int x1[]=new int[DEPTH];         // 3Dの表示位置パラメータ
  private int y1[]=new int[DEPTH];
  private int dx[]=new int[DEPTH];
  private int dy[]=new int[DEPTH];
  int nw[]=new int[DEPTH];
  private int vwallx[]=new int[4];
  private int vwally[]=new int[4];
  private int vdoorx[]=new int[4];
  private int vdoory[]=new int[4];
  private int fx,fy;

  draw3D(int fx,int fy,int depth){
    set3DMesh(fx,fy,depth);
  }

//--------------------------------------------------------------------//
  void set3DMesh(int fx,int fy,int depth){
// ３次元地図のマス目設定
    int i;

    this.fx=fx;
    this.fy=fy;
    depth=Math.min(depth,DEPTH-2);
    x1[0]=0;          y1[0]=0;
    dx[0]=fx;         dy[0]=fy;
    x1[1]=fx/10;      y1[1]=fy/10;
    dx[1]=fx-2*x1[1]; dy[1]=fy-2*y1[1];
    nw[0]=0;          nw[1]=1;
    for(i=2;i<=depth+1;i++){
      x1[i]=(fx/2-x1[i-1])/3+x1[i-1];
      y1[i]=(fy/2-y1[i-1])/3+y1[i-1];
      dx[i]=fx-2*x1[i];
      dy[i]=fy-2*y1[i];
      nw[i]=(fx/dx[i]+1)/2;
    }
  }

//--------------------------------------------------------------------//
  void draw3DMap(Graphics g,int x0,int y0,int depth,int x
      	      	,Color lineColor,Color wallColor,Color swallColor
      	      	,Color doorColor,int ww[],KeyDoor kd[]){
// ３次元地図表示
    int xx[]=new int[2];
    int dxx,i;

    xx[0]=x1[depth]+dx[depth]*x;
    xx[1]=x1[depth]-dx[depth]*x;
    dxx=dx[depth];
    if(xx[0]<0){
      dxx+=xx[0];
      xx[0]=0;
      xx[1]=fx-dxx;
    }
    for(i=0;i<2;i++){
      if(ww[i]==WALL){
      	draw3DWall(g,wallColor,lineColor,x0+xx[i],y0+y1[depth],dxx,dy[depth]);
      }
      else if(ww[i]==DOOR){
      	draw3DWall(g,wallColor,lineColor,x0+xx[i],y0+y1[depth],dxx,dy[depth]);
      	draw3DDoor(g,doorColor,lineColor,x0,y0,xx[i],depth,x);
      }
      else if(ww[i]<0){
      	draw3DWall(g,wallColor,lineColor,x0+xx[i],y0+y1[depth],dxx,dy[depth]);
      	draw3DDoor(g,kd[-ww[i]].color,lineColor,x0,y0,xx[i],depth,x);
      }
    }
    if(nw[depth]+x!=0 && nw[depth-1]+x>=0){
      xx[0]=x;
      xx[1]=1-x;
      for(i=0;i<2;i++){
      	make3DSideWall(depth,xx[i],x0,x0+fx,y0,fy);
      	if(ww[i+2]==WALL){
      	  draw3DSideWall(g,swallColor,lineColor,vwallx,vwally);
      	}
      	else if(ww[i+2]==DOOR){
      	  draw3DSideWall(g,swallColor,lineColor,vwallx,vwally);
      	  make3DSideDoor(depth-1,xx[i],x0,x0+fx,y0);
      	  draw3DSideWall(g,doorColor,lineColor,vdoorx,vdoory);
      	}
      	else if(ww[i+2]<0){
      	  draw3DSideWall(g,swallColor,lineColor,vwallx,vwally);
      	  make3DSideDoor(depth-1,xx[i],x0,x0+fx,y0);
      	  draw3DSideWall(g,kd[-ww[i+2]].color,lineColor,vdoorx,vdoory);
      	}
      }
    }
  }

//--------------------------------------------------------------------//
  void init3DMap(Graphics g,int x0,int y0,int depth,Color ceilColor
      	      	,Color floorColor){
// ３次元地図表示初期化

    g.setColor(ceilColor);
    g.fillRect(x0,y0,fx,y1[depth]);
    g.setColor(Color.black);
    g.fillRect(x0,y0+y1[depth],fx,fy-2*y1[depth]);
    g.setColor(floorColor);
    g.fillRect(x0,y0+fy-y1[depth],fx,y1[depth]);
  }

//--------------------------------------------------------------------//
  void make3DSideWall(int i,int j,int x0,int xmax,int y0,int ymax){
// 横壁表示座標データ作成
    vwally[0]=y0+y1[i-1];
    vwally[1]=y0+y1[i];
    vwally[2]=vwally[1]+dy[i];
    vwally[3]=vwally[0]+dy[i-1];
    vwallx[0]=x0+x1[i-1]+dx[i-1]*j;
    vwallx[1]=x0+x1[i]+dx[i]*j;
    if(vwallx[0]<x0){
      vwally[0]+=(vwally[1]-vwally[0])*(x0-vwallx[0])
      	      	/(vwallx[1]-vwallx[0]);
      vwally[3]=2*y0+ymax-vwally[0];
      vwallx[0]=x0;
    }
    else if(vwallx[0]>xmax){
      vwally[0]+=(vwally[1]-vwally[0])*(xmax-vwallx[0])
      	      	/(vwallx[1]-vwallx[0]);
      vwally[3]=2*y0+ymax-vwally[0];
      vwallx[0]=xmax;
    }
    vwallx[2]=vwallx[1];
    vwallx[3]=vwallx[0];
  }

//--------------------------------------------------------------------//
  void make3DSideDoor(int i,int j,int xmin,int xmax,int ymin){
// 横扉表示座標データ作成
    int ddx;

    vwallx[0]=xmin+x1[i]+dx[i]*j;
    vwally[0]=ymin+y1[i];
    vwally[3]=vwally[0]+dy[i];
    if(i==0){
      vdoorx[0]=vwallx[0];
      vdoorx[1]=(vwallx[0]+vwallx[1])/2;
      vdoory[0]=vwally[0];
      vdoory[1]=(vwally[0]+vwally[1])/2;
      vdoory[2]=(vwally[3]+vwally[2])/2;
      vdoory[3]=vwally[3];
    }
    else{
      vdoorx[0]=(3*vwallx[0]+vwallx[1])/4;
      vdoorx[1]=(vwallx[0]+3*vwallx[1])/4;
      vdoory[0]=(3*vwally[0]+vwally[1])/4;
      vdoory[1]=(vwally[0]+3*vwally[1])/4;
      vdoory[2]=(vwally[3]+3*vwally[2])/4;
      vdoory[3]=(3*vwally[3]+vwally[2])/4;
    }
    vdoory[0]+=(vdoory[3]-vdoory[0])/5;
    vdoory[1]+=(vdoory[2]-vdoory[1])/5;
    ddx=vdoorx[1]-vdoorx[0];
    if(vdoorx[0]<xmin){
      vdoory[0]+=(vdoory[1]-vdoory[0])*(xmin-vdoorx[0])/ddx;
      vdoory[3]+=(vdoory[2]-vdoory[3])*(xmin-vdoorx[0])/ddx;
      vdoorx[0]=xmin;
    }
    else if(vdoorx[0]>xmax){
      vdoory[0]+=(vdoory[1]-vdoory[0])*(xmax-vdoorx[0])/ddx;
      vdoory[3]+=(vdoory[2]-vdoory[3])*(xmax-vdoorx[0])/ddx;
      vdoorx[0]=xmax;
    }
    vdoorx[2]=vdoorx[1];
    vdoorx[3]=vdoorx[0];
  }

//--------------------------------------------------------------------//
  void draw3DWall(Graphics g,Color wallColor,Color lineColor
      	      	 ,int x0,int y0,int xx,int yy){
// 前壁描画
    g.setColor(wallColor);
    g.fillRect(x0,y0,xx,yy);
    g.setColor(lineColor);
    g.drawRect(x0,y0,xx,yy);
  }

//--------------------------------------------------------------------//
  void draw3DSideWall(Graphics g,Color wallColor,Color lineColor
      	      	     ,int xx[],int yy[]){
// 横壁描画
    g.setColor(wallColor);
    g.fillPolygon(xx,yy,4);
    g.setColor(lineColor);
    g.drawPolygon(xx,yy,4);
  }

//--------------------------------------------------------------------//
  void draw3DDoor(Graphics g,Color wallColor,Color lineColor
      	      	 ,int x0,int y0,int xx0,int i,int j){
// 前扉描画
    int drx0,drx,dry0;

    drx0=dx[i]/4;
    drx=dx[i]-2*drx0;
    dry0=dy[i]/5;
    if(xx0==0){
      drx0+=x1[i]+dx[i]*j;
      if(drx0<0){
      	drx+=drx0;
      	drx0=0;
      }
    }
    else if(xx0+drx0+drx>fx){
      drx=fx-xx0-drx0;
    }
    draw3DWall(g,wallColor,lineColor,x0+xx0+drx0,y0+y1[i]+dry0
      	      ,drx,dy[i]-dry0);
  }
}