/*============================================================================
  NuSYSTEM サンプルプログラム「SNAKE TAIL HACK」
  
  gamemain.c
  
  Copyright (C) 1997, NINTENDO Co,Ltd.
  ============================================================================*/

#include <assert.h>
#include <nusys.h>
#include <nualsgi_n.h>

#include "main.h"
#include "graphic.h"
#include "math.h"
#include "font.h"
#include "para.h"

#include "./kiyaata1.h"/*プレイヤー１のヘッドのモデルデータ*/
#include "./kiyadou1.h"/*プレイヤー１のテイルのモデルデータ*/
#include "./kiyaata2.h"/*プレイヤー２のヘッドのモデルデータ*/
#include "./kiyadou2.h"/*プレイヤー２のテイルのモデルデータ*/
#include "./kiyaata3.h"/*プレイヤー３のヘッドのモデルデータ*/
#include "./kiyadou3.h"/*プレイヤー３のテイルのモデルデータ*/
#include "./kiyaata4.h"/*プレイヤー４のヘッドのモデルデータ*/
#include "./kiyadou4.h"/*プレイヤー４のテイルのモデルデータ*/

#define START_TIME	100000000LL/* 100秒 */
#define TAIL_NUM	0
#define TIME_UP		1

/* 関数宣言 */
void InitSnake( void );
void InitShotTail( void );
void DrawHead( Dynamic* , int );
void UpdateTailPos( int );
void RecordHeadPos( int );
void DrawTail( Dynamic* , int );
void ChgHeadDir( int, int, int);
void DrawShotTail( Dynamic* );
void EntryShotTail( int, int );
void EraseShotTail( int );
void ShotTailMove( void );
void SlideTail( int );
void ReadMovie( int , Dynamic* );
void DrawInfo( void );
int CheckTailNum( int );
void InitGame( void );

/* extern宣言 */
/* nusys */
extern u32 nuScRetraceCounter;    /* リトレースカウンター */

/* gameover.c */
extern int SavePak;
extern int SavePakEnd;

/* map.c */
extern void DrawMap( Dynamic* dynamicp );
extern void DrawMapSaku( Dynamic* dynamicp );
extern void DrawMapObj( Dynamic* );
extern void DrawMovie( Dynamic* dynamicp, unsigned short * );

/* hitchk.c */
extern void Snake2Wall( int );
extern void Snake2Obj( int );
extern void Snake2Enemy( int );
extern int ShotTail2Wall( float, float );
extern int ShotTail2Obj( float, float );
extern void Snake2ShotTail( int );
extern void Snake2EnemyTail( int );

/* main.c */
extern void SaveContPak( void );
extern NUContData ContTriger[];
extern int TraceIdx;
extern int ReplayMode;
volatile extern int stage;

/* view.c */
extern void SetViewMtx( Dynamic* dynamicp );

/* spec */
extern u8 _moviedataSegmentRomStart[];
extern u8 _moviedataSegmentRomEnd[];


/* 変数宣言 */
float View;		/* カメラ位置 */
int MovieNumber;	/* ムービー用テクスチャー番号 */
SnakePara Snake;	/* 自機の各種パラメーター */
SnakeMove snakemove[4];	/* 自機の胴体描画用バッファ */
ShotTail mtx_shot[20];	/* 打ち出したテイルの各種パラメーター */

int Pause;		/* ポーズ用フラグ */
int MovieUpDate;	/* ムービーアップデート用カウンター */

OSTime	StartTime;	/* ゲーム開始時間 */
OSTime	NowTime;	/* 現在の時間 */
OSTime	NowPauseTime;	/* ポーズ時の時間保持用 */
OSTime	LapTime;	/* 経過時間 */

int Winner;		/* 勝利者番号 */
int UpTempo;		/* シーケンステンポアップ用フラグ */

/*--------------------------------------------------------------*/
/*  makegameDL							*/
/*  ディスプレイリストを作り、グラフィックタスクを起動します。	*/
/*  IN:	なし							*/
/*  RET:なし							*/
/* -------------------------------------------------------------*/
void
makegameDL(void)
{
    int idx;
    Dynamic* dynamicp;

    /* ダイナミックバッファの指定 */
    dynamicp = &gfx_dynamic[gfx_gtask_no];

    /* ディスプレイリストバッファの指定 */
    glistp = &gfx_glist[gfx_gtask_no][0];

    /* RSP,RDPの初期化 */
    gfxRCPInit();

    /* フレームバッファとＺバッファのクリア*/
    gfxClearCfb();

    /* 視点マトリックスの設定 */
    SetViewMtx( dynamicp );

    /* マップの描画 */
    DrawMap( dynamicp );
    DrawMapSaku( dynamicp );
    DrawMapObj( dynamicp );

    /* ムービー用テクスチャ─をＰＩで読み込む */
    ReadMovie( MovieNumber, dynamicp );

    /* MovieBufに読み込まれたテクスチャ─を描画します（MovieBuf[0]~MovieBuf[3]は使わないデータ */
    DrawMovie( dynamicp, &(dynamicp->MovieBuf[4]));

    /* 自機の描画 */
    for(idx = 0; idx < 4; idx++){
	UpdateTailPos( idx );
	DrawTail( dynamicp, idx );
	DrawHead( dynamicp, idx );
    }

    /* 打ち出されたテイルの描画 */
    DrawShotTail( dynamicp );

    /*画面情報を表示*/
    DrawInfo();
    
    gDPFullSync(glistp++);
    gSPEndDisplayList(glistp++);

    assert((glistp - gfx_glist[gfx_gtask_no]) < GFX_GLIST_LEN);
   	
    /* RSPタスクを起動し、表示バッファを切り替えます。*/
    nuGfxTaskStart(&gfx_glist[gfx_gtask_no][0],
		   (s32)(glistp - gfx_glist[gfx_gtask_no]) * sizeof (Gfx),
		   NU_GFX_UCODE_F3DEX , NU_SC_SWAPBUFFER);

    /* 次のグラフィックタスク番号の指定 */
    gfx_gtask_no++;
    gfx_gtask_no %= GFX_GTASK_NUM;
}


/*------------------------------*/
/* updateGame			*/
/* ゲームメイン部分の進行処理	*/
/*  IN:	なし			*/
/*  RET:なし			*/
/*------------------------------*/
void
updateGame(void)
{
    int padnum;
    int idx;
    int EnemyNum, EnemyTailNum;
    s32 tempo;

    /* PAUSE */
    if(ContTriger[0].trigger & START_BUTTON){
	nuAuSndPlayerPlay(EFF_PAUSE);
	nuAuSndPlayerSetPitch(44100.0/32000);
	Pause ^= 1;
    }

    
    /* リセット */
    if((ContTriger[0].trigger & L_TRIG) &&
       (ContTriger[0].trigger & R_TRIG)){
	/* コールバック関数を取り除く。*/
	nuGfxFuncRemove();
	/* タイトルに戻ります */
	stage = 0;
    }

    /* タイマー更新 */
    if( Pause == 0 ){
	NowTime = osGetTime();
	NowPauseTime = NowTime - StartTime;
	LapTime = START_TIME - OS_CYCLES_TO_USEC(NowTime - StartTime);
	LapTime /= 1000;
    }else{    /* タイム保持 */
	NowTime = osGetTime();
	StartTime = NowTime - NowPauseTime;
	LapTime = START_TIME - OS_CYCLES_TO_USEC(NowTime - StartTime);
	LapTime /= 1000;
    }

    /* テイルの数による終了（テイルが２０個になったら）*/
    if(CheckTailNum(TAIL_NUM)){
	/* 次のステージをメインに指示 */
	stage = 2;
	SavePak = 0;
	SavePakEnd = 0;
	/* コールバック関数を取り除く。*/
	nuGfxFuncRemove();
    }

    /* タイムアップによる終了 */
    if(LapTime > NowTime){
	CheckTailNum(TIME_UP);
	LapTime = 0;
	/* 次のステージをメインに指示 */
	stage = 2;
	SavePak = 0;
	SavePakEnd = 0;
	/* コールバック関数を取り除く。*/
	nuGfxFuncRemove();
    }

    /* カメラの位置を変更します */
    if(nuContData[0].button & U_CBUTTONS){
	if((View += 1.0) > 89.0){
	    View = 89.0;
	}
    }
    /* 同上 */
    if(nuContData[0].button & D_CBUTTONS){
	if((View -= 1.0) <= -89.0){
	    View = -89.0;
	}
    }

    /* ポーズ中でなかったら */
    if(Pause == 0){
	/* パッドごとの更新処理 */
	for(padnum = 0; padnum < NU_CONT_MAXCONTROLLERS; padnum++){

	    /* もし、コントローラーパッドがつながっていなかったら次へ */
	    /* main.c の nuContInit() による初期化の結果による */
	    if(nuContStatus[padnum].errno != 0){
		continue;
	    }

	    /* 気絶中だったら次へ */
	    if(Snake.sleepcnt[padnum] > 0){
		continue;
	    }

	    /* ヘッドが敵のテイルに重なってなかったら */
	    if(Snake.enemytailhit[padnum] == -1 ){
		/* Ａボタン */
		if(ContTriger[padnum].trigger & A_BUTTON){
		    /* 打ち出すテイルがエントリーできたらエントリーする */
		    if(Snake.tailcnt[padnum] > 0){
			nuAuSndPlayerPlay(EFF_SHOT_TAIL);
			nuAuSndPlayerSetPitch(44100.0/32000);
			EntryShotTail( padnum, Snake.tail_attr[padnum][1]);
		    }
		}
	    }else{		/* ヘッドが敵のテイルに重なっていたら */
		/* Ａボタン */
		EnemyNum = Snake.enemytailhit[padnum];
		EnemyTailNum = Snake.enemytailhitnum[padnum];

		/* 敵のテイルを奪う */
		if(ContTriger[padnum].button & A_BUTTON){
		    nuAuSndPlayerPlay(EFF_EAT_TAIL);
		    nuAuSndPlayerSetPitch(44100.0/32000);
		    for(idx = EnemyTailNum; idx < Snake.tailcnt[EnemyNum]+1; idx++){
			Snake.tail_attr[padnum][++Snake.tailcnt[padnum]] =
			  Snake.tail_attr[EnemyNum][idx];
			Snake.tail_attr[EnemyNum][idx] = -1;
		    }
		    /* 奪われた方のテイルを短くする */
		    Snake.tailcnt[EnemyNum] = EnemyTailNum - 1;
		}
	    }

	    /* ３ＤスティックがＸＹそれぞれ-3〜3の間の時は動かさない（あそび）*/
	    if(!((nuContData[padnum].stick_x/10 < 3 &&
		  nuContData[padnum].stick_x/10 > -3) &&
		 (nuContData[padnum].stick_y/10 < 3 &&
		  nuContData[padnum].stick_y/10 > -3 ))){

		/* ヘッドを３Ｄスティックで動かす（上下左右何れかの方向）*/
		if( Zettai(nuContData[padnum].stick_x/5) >
		   Zettai(nuContData[padnum].stick_y/5) ){
		    Snake.pos_x[padnum][0] += nuContData[padnum].stick_x/5;
		    nuContData[padnum].stick_y = 0;
		    /* ３Ｄスティックの傾きに合わせてヘッドの頭の方向を変える */
		    ChgHeadDir( padnum, nuContData[padnum].stick_x, 0 ); 
		}else{
		    Snake.pos_y[padnum][0] += nuContData[padnum].stick_y/5;
		    nuContData[padnum].stick_x = 0;
		    /* ３Ｄスティックの傾きに合わせてヘッドの頭の方向を変える */
		    ChgHeadDir( padnum, 0, nuContData[padnum].stick_y ); 
		}
		Snake.stickon[padnum] = 1;
	    }else{
		Snake.stickon[padnum] = 0;
	    }

	    Snake2Wall( padnum ); /* 自機とマップエリアとの当り判定 */
	    Snake2Obj( padnum ); /* 自機とマップオブジェクトとの当り判定 */
	    Snake2Enemy( padnum ); /* 自機と敵との当り判定 */
	    Snake2EnemyTail( padnum ); /* 自機と敵のテイルとの当り判定 */

	
	    /* もし何かに当ったら、元に戻す */
	    if(Snake.wallhit[padnum] == 1 ||	/* 壁に当った */
	       Snake.objhit[padnum] != -1 ||	/* マップオブジェクトに当った */
	       Snake.enemyhit[padnum] != -1){	/* 敵に当った */
		Snake.pos_x[padnum][0] -= nuContData[padnum].stick_x/5;
		Snake.pos_y[padnum][0] -= nuContData[padnum].stick_y/5;
	    }else{
		if(Snake.stickon[padnum]) /* ３Ｄスティックがある程度倒れてたら */
		  RecordHeadPos( padnum ); /* ヘッドの軌跡をバッファに記録します */
	    }

	    /* 自機と飛んできたテイルとの当り判定 */
	    Snake2ShotTail( padnum );
	    if(Snake.shottailhit[padnum] != -1){
		nuAuSndPlayerPlay(EFF_CUR_MOVE);
		nuAuSndPlayerSetPitch(44100.0/32000);
		
		/* 自機に繋がってるテイルを１個増やす（ＭＡＸ２０個）*/
		if((Snake.tailcnt[padnum]++) >= 20){
		    Snake.tailcnt[padnum] = 20;
		}
		/* 当ったテイルを自分の後端に登録 */
		Snake.tail_attr[padnum][Snake.tailcnt[padnum]] =
		  mtx_shot[Snake.shottailhit[padnum]].tail_pattern;
		/* 打ち出されたテイルの登録を抹消 */
		EraseShotTail( Snake.shottailhit[padnum] ); 
	    }
	}
	ShotTailMove();		/* 打ち出したテイルがあれば動かす */

	/* 指定リトレースおきに次のテクスチャ─ナンバーにインクリメント（０〜１５）*/
	if((MovieUpDate % MOVIE_UPDATE) == 0) {
	    if((++MovieNumber) > 15){
		MovieNumber = 0;
	    }
	}
	MovieUpDate++;
	/* 残り時間が３０秒を切ったら曲のテンポを上げる */
	if(UpTempo == 0 && (LapTime/1000) < 30){
	    UpTempo = 1;
	    tempo = nuAuSeqPlayerGetTempo(0);
	    tempo /= 13;
	    tempo *= 10;
	    nuAuSeqPlayerSetTempo(0,tempo);
	}
	/* 残り時間が３０秒以下の時にカウントダウン */
	if(((LapTime/1000) < 32) && ((LapTime/1000) > 1)){
	    if(((LapTime/100) % 10) == 0){
		nuAuSndPlayerPlay(EFF_TIME_DWN1);
		nuAuSndPlayerSetPitch(44100.0/32000);
	    }
	}
	if((LapTime/1000) == 1){
	    if(((LapTime/100) % 10) == 0){
		nuAuSndPlayerPlay(EFF_TIME_DWN2);
		nuAuSndPlayerSetPitch(44100.0/32000);
	    }
	}
    }
}

/*------------------------------*/
/*  各種パラメーターの初期化	*/
/*  IN:	なし			*/
/*  RET:なし			*/
/*------------------------------*/
void
InitSnake( void )
{
    int idx, idx2;
    /* 自機の初期化（プレイヤー毎に違うパラメーター分） */
    for(idx = 0; idx < SNAKE_MAX_LEN + 1; idx++){
	/* プレイヤー１のポジション */
	Snake.pos_x[0][idx] = -BASE_MAX_SIZE+50;
	Snake.pos_y[0][idx] = BASE_MAX_SIZE-50;
	Snake.pos_z[0][idx] = 30.0;
	/* ヘッドの向き */
	Snake.head_dir[0] = 0.0;

	/* プレイヤー１のポジション */
	Snake.pos_x[1][idx] = -BASE_MAX_SIZE+50;
	Snake.pos_y[1][idx] = -BASE_MAX_SIZE+50;
	Snake.pos_z[1][idx] = 30.0;
	/* ヘッドの向き */
	Snake.head_dir[1] = 90.0;

	/* プレイヤー１のポジション */
	Snake.pos_x[2][idx] = BASE_MAX_SIZE-50;
	Snake.pos_y[2][idx] = BASE_MAX_SIZE-50;
	Snake.pos_z[2][idx] = 30.0;
	/* ヘッドの向き */
	Snake.head_dir[2] = 270.0;

	/* プレイヤー１のポジション */
	Snake.pos_x[3][idx] = BASE_MAX_SIZE-50;
	Snake.pos_y[3][idx] = -BASE_MAX_SIZE+50;
	Snake.pos_z[3][idx] = 30.0;
	/* ヘッドの向き */
	Snake.head_dir[3] = 180.0;
    }
    /* Ｚ軸ポジションは全て共通 */
    Snake.pos_z[0][0] = 40.0;
    Snake.pos_z[1][0] = 40.0;
    Snake.pos_z[2][0] = 40.0;
    Snake.pos_z[3][0] = 40.0;

    for(idx = 0; idx < SNAKE_MAX; idx++){
	for(idx2 = 0; idx2 < SNAKE_MAX_LEN + 1; idx2++){
	    /* スネークの向き（ヘッドの向きと同じです） */
	    Snake.rot_x[idx][idx2] = 0.0;
	    Snake.rot_y[idx][idx2] = 0.0;
	    Snake.rot_z[idx][idx2] = Snake.head_dir[idx];

	    /* 描画サイズ */
	    Snake.size_x[idx][idx2] = 2.0;
	    Snake.size_y[idx][idx2] = 2.0;
	    Snake.size_z[idx][idx2] = 2.0;
	}
    }
    
    for(idx = 0; idx < SNAKE_MAX; idx++){
	Snake.tailcnt[idx] = 5;
	Snake.wallhit[idx] = 0;
	Snake.objhit[idx] = -1;
	Snake.enemyhit[idx] = -1;
	Snake.bufidx[idx] = TAIL_MOVE_BUF-1;
	Snake.enemytailhit[idx] = -1;
	Snake.enemytailhitnum[idx] = -1;
	Snake.sleepcnt[idx] = 0;
    }

    /* テイルの種類の設定 */
    for(idx = 1; idx < 6; idx++){
	Snake.tail_attr[0][idx] = 0;
	Snake.tail_attr[1][idx] = 1;
	Snake.tail_attr[2][idx] = 2;
	Snake.tail_attr[3][idx] = 3;
    }

    /* 自機の胴体描画用バッファの初期化 */
    /* とりあえず、デフォルトの位置にする */
    for(idx2 = 0; idx2 < 4; idx2++){
	for(idx = 0; idx < TAIL_MOVE_BUF; idx++){
	    snakemove[idx2].SnakeX[idx] = Snake.pos_x[idx2][0];
	    snakemove[idx2].SnakeY[idx] = Snake.pos_y[idx2][0];
	    snakemove[idx2].SnakeRotZ[idx] = Snake.rot_z[idx2][0];
	}
    }
}


/*------------------------------*/
/*  打ち出すテイルの初期化	*/
/*  IN:	なし			*/
/*  RET:なし			*/
/*------------------------------*/
void
InitShotTail( void )
{
    int idx;

    for( idx = 0; idx < 20; idx++ ){
	/* ポジション */
	mtx_shot[idx].pos_x = 0.0;
	mtx_shot[idx].pos_y = 0.0;
	mtx_shot[idx].pos_z = 20.0;
	
	/* 回転 */
	mtx_shot[idx].rot_x = 0.0;
	mtx_shot[idx].rot_y = 0.0;
	mtx_shot[idx].rot_z = 0.0;
	
	/* サイズ */
	mtx_shot[idx].size_x = 2.0;
	mtx_shot[idx].size_y = 2.0;
	mtx_shot[idx].size_z = 2.0;
	
	/* 種類 */
	mtx_shot[idx].tail_pattern = -1;
	
	/* 方向 */
	mtx_shot[idx].tail_dir = 0.0;

	/* ステータス */
	mtx_shot[idx].status = TAIL_NOTHING;

	/* 打ち出した人 */
	mtx_shot[idx].user = -1;
    }
}
/*------------------------------------------------------*/
/*  ショット用テイルのエントリー			*/
/*  IN:	PadNum		登録するプレイヤーナンバー	*/
/*  	TailAttr	登録するテイルの種類		*/
/*  RET:なし						*/
/*------------------------------------------------------*/
void
EntryShotTail( int PadNum, int TailAttr )
{
    int idx;

    for(idx = 0; idx < 20; idx++){
	if(mtx_shot[idx].tail_pattern == -1){
	    mtx_shot[idx].pos_x =
	      Snake.pos_x[PadNum][0] + cosf(2.0*M_PI/(360/Snake.head_dir[PadNum]))*HEAD_SIZE;
	    mtx_shot[idx].pos_y =
	      Snake.pos_y[PadNum][0] + sinf(2.0*M_PI/(360/Snake.head_dir[PadNum]))*HEAD_SIZE;

	    /* エントリーした場所がマップの範囲外だったら、エントリーしない */
	    /* エントリーした場所がマップオブジェクト上だったら、エントリーしない */
	    if(ShotTail2Wall( mtx_shot[idx].pos_x,mtx_shot[idx].pos_y ) ||
	       ShotTail2Obj( mtx_shot[idx].pos_x,mtx_shot[idx].pos_y ) != -1){
		return;
	    }

	    mtx_shot[idx].pos_z = Snake.pos_z[PadNum][0];
	    mtx_shot[idx].tail_pattern = TailAttr;

	    mtx_shot[idx].rot_x = Snake.rot_x[PadNum][0];
	    mtx_shot[idx].rot_y = Snake.rot_y[PadNum][0];
	    mtx_shot[idx].rot_z = Snake.rot_z[PadNum][0];

	    mtx_shot[idx].tail_dir = Snake.head_dir[PadNum];
	    mtx_shot[idx].status = TAIL_MOVING;
	    mtx_shot[idx].user = PadNum;

	    SlideTail( PadNum );
	    if((--Snake.tailcnt[PadNum]) < 0){
		Snake.tailcnt[PadNum] = 0;
	    }
	    return;
	}
    }
}

/*----------------------------------------------*/
/*  ショット用テイルの登録抹消			*/
/*  IN:	ShotTailNum	登録したテイルナンバー	*/
/*  RET:なし					*/
/*----------------------------------------------*/
void
EraseShotTail( int ShotTailNum )
{
    mtx_shot[ShotTailNum].pos_x = 0.0;
    mtx_shot[ShotTailNum].pos_y = 0.0;
    mtx_shot[ShotTailNum].pos_z = 20.0;
    
    mtx_shot[ShotTailNum].rot_x = 0.0;
    mtx_shot[ShotTailNum].rot_y = 0.0;
    mtx_shot[ShotTailNum].rot_z = 0.0;
    
    mtx_shot[ShotTailNum].size_x = 2.0;
    mtx_shot[ShotTailNum].size_y = 2.0;
    mtx_shot[ShotTailNum].size_z = 2.0;
    
    mtx_shot[ShotTailNum].tail_pattern = -1;
    
    mtx_shot[ShotTailNum].tail_dir = 0.0;

    /* ステータス */
    mtx_shot[ShotTailNum].status = TAIL_NOTHING;
}

/*--------------------------------------*/
/*  自機のテイルをローテートします	*/
/*  IN:	PadNum	プレイヤーナンバー	*/
/*  RET:なし				*/
/*--------------------------------------*/
void
SlideTail( int PadNum )
{
    int idx;
    if(Snake.tailcnt[PadNum] >= 2){
	for(idx = 1; idx < Snake.tailcnt[PadNum]+1; idx++){
	    Snake.tail_attr[PadNum][idx] = Snake.tail_attr[PadNum][idx+1];
	}
    }
}

/*------------------------------*/
/*  打ち出したテイルの動き	*/
/*  IN:	なし			*/
/*  RET:なし			*/
/*------------------------------*/
void
ShotTailMove( void )
{
    int idx;
    float ChkX,ChkY;

    for(idx = 0; idx < 20; idx++){
	if( mtx_shot[idx].tail_pattern == -1){
	    continue;
	}
	/* ヘッドの向きから、打ち出したテイルのベクトルを取得 */
	ChkX = cosf(2.0*M_PI/(360/mtx_shot[idx].tail_dir))*SHOT_SPEED;
	ChkY = sinf(2.0*M_PI/(360/mtx_shot[idx].tail_dir))*SHOT_SPEED;

	/* 実際に動かしてみる */
	mtx_shot[idx].pos_x += ChkX;
	mtx_shot[idx].pos_y += ChkY;
    
	/* 壁、障害物に当った */
	if(ShotTail2Wall( mtx_shot[idx].pos_x,mtx_shot[idx].pos_y ) ||
	   ShotTail2Obj( mtx_shot[idx].pos_x,mtx_shot[idx].pos_y ) != -1){
	    /* 元に戻す */
	    mtx_shot[idx].pos_x -= ChkX;
	    mtx_shot[idx].pos_y -= ChkY;
	    mtx_shot[idx].status = TAIL_WAITING;
	}
	/* 打ち出したテイルを回転させます */
	mtx_shot[idx].rot_z += 10.0;
    }
}


/*--------------------------------------*/
/*  自機表示（頭）			*/
/*  IN:	dp	ダイナミックポインタ	*/
/*      Padnum	プレイヤーナンバー	*/
/*  RET:なし				*/
/*--------------------------------------*/
void
DrawHead( Dynamic* dp, int PadNum )
{
    /* モデル座標系の計算 */
    guTranslate(&(dp->snake_trans[PadNum][0]),
		Snake.pos_x[PadNum][0],
		Snake.pos_y[PadNum][0],
		Snake.pos_z[PadNum][0]);
    guScale(&(dp->snake_scale[PadNum][0]),
	    Snake.size_x[PadNum][0],
	    Snake.size_y[PadNum][0],
	    Snake.size_z[PadNum][0]);

    /* 気絶中 */
    if((--Snake.sleepcnt[PadNum]) > 0){
	if(0x2 > (nuScRetraceCounter & 0x2)) {
	    Snake.rot_y[PadNum][0] += 3.0;
	}else{
	    Snake.rot_y[PadNum][0] -= 3.0;
	}
    }else{
	Snake.sleepcnt[PadNum] = 0;
	Snake.rot_y[PadNum][0] = 0.0;
    }

    guRotateRPY(&(dp->snake_rotate[PadNum][0]),
		Snake.rot_x[PadNum][0]+90.0,
		Snake.rot_y[PadNum][0],
		Snake.rot_z[PadNum][0]+90.0);

    /* モデルマトリックスの設定 */

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->snake_trans[PadNum][0])),
	      G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->snake_scale[PadNum][0])),
	      G_MTX_MODELVIEW | G_MTX_MUL | G_MTX_NOPUSH);

    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->snake_rotate[PadNum][0])),
	      G_MTX_MODELVIEW | G_MTX_MUL | G_MTX_NOPUSH);

    /* アンチエイリアス無し、不透明サーフェース */
    gDPSetRenderMode(glistp++,G_RM_ZB_OPA_SURF, G_RM_ZB_OPA_SURF2);

    /* ジオメトリーのクリア、設定 */
    gSPClearGeometryMode(glistp++,0xFFFFFFFF);
    gSPSetGeometryMode(glistp++, G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH | G_LIGHTING |
		       G_CULL_BACK);

    gDPSetCycleType(glistp++, G_CYC_1CYCLE);
    /* コンバイナの設定 */
    gDPSetCombineMode(glistp++,G_CC_DECALRGB, G_CC_DECALRGB);
    
    /* モデルのディスプレイリスト */
    switch(PadNum){
      case 0:
	gSPDisplayList(glistp++,kiyaata1_mdl_model0);
	break;
      case 1:
	gSPDisplayList(glistp++,kiyaata2_mdl_model0);
	break;
      case 2:
	gSPDisplayList(glistp++,kiyaata3_mdl_model0);
	break;
      case 3:
	gSPDisplayList(glistp++,kiyaata4_mdl_model0);
	break;
      default:
	break;
    }
	 
    gDPPipeSync(glistp++);
}


/*--------------------------------------*/
/*  自機表示（しっぽ）			*/
/*  IN:	dp	ダイナミックポインタ	*/
/*      Padnum	プレイヤーナンバー	*/
/*  RET:なし				*/
/*--------------------------------------*/
void
DrawTail( Dynamic* dp, int PadNum )
{
    int MaxTail,idx;

    MaxTail = Snake.tailcnt[PadNum];

    /* 一番後ろテイルから描画します */
    for(idx = MaxTail; idx >= 1; idx--){
	/* モデル座標系の計算 */
	guTranslate(&(dp->snake_trans[PadNum][idx]),
		    Snake.pos_x[PadNum][idx],
		    Snake.pos_y[PadNum][idx],
		    Snake.pos_z[PadNum][idx]
		    );
	guScale(&(dp->snake_scale[PadNum][idx]),
		Snake.size_x[PadNum][idx],
		Snake.size_y[PadNum][idx],
		Snake.size_z[PadNum][idx]
		);

	guRotateRPY(&(dp->snake_rotate[PadNum][idx]),
		    Snake.rot_x[PadNum][idx]+90.0,
		    Snake.rot_y[PadNum][idx],
		    Snake.rot_z[PadNum][idx]+90.0
		    );

	
	/* モデルマトリックスの設定 */
	gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->snake_trans[PadNum][idx])),
		  G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);

	gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->snake_scale[PadNum][idx])),
		  G_MTX_MODELVIEW | G_MTX_MUL | G_MTX_NOPUSH);

	gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->snake_rotate[PadNum][idx])),
		  G_MTX_MODELVIEW | G_MTX_MUL | G_MTX_NOPUSH);

	/* アンチエイリアス無し、不透明サーフェース */
	gDPSetRenderMode(glistp++,G_RM_ZB_OPA_SURF, G_RM_ZB_OPA_SURF2);

	/* ジオメトリーのクリア、設定 */
	gSPClearGeometryMode(glistp++,0xFFFFFFFF);
	gSPSetGeometryMode(glistp++, G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH |
			   G_LIGHTING | G_CULL_BACK);

	gDPSetCycleType(glistp++, G_CYC_1CYCLE);
	/* コンバイナの設定 */
	gDPSetCombineMode(glistp++,G_CC_DECALRGB, G_CC_DECALRGB);

	/* モデルのディスプレイリスト */
	switch(Snake.tail_attr[PadNum][idx]){
	  case 0:
	    gSPDisplayList(glistp++,kiyadou1_mdl_model0);
	    break;
	  case 1:
	    gSPDisplayList(glistp++,kiyadou2_mdl_model0);
	    break;
	  case 2:
	    gSPDisplayList(glistp++,kiyadow3_mdl_model0);
	    break;
	  case 3:
	    gSPDisplayList(glistp++,kiyadow4_mdl_model0);
	    break;
	  default:
	    break;
	}
	gDPPipeSync(glistp++);
    }
}

/*--------------------------------------*/
/*  ヘッドの軌跡をバッファに記録	*/
/*  IN: Padnum	プレイヤーナンバー	*/
/*  RET:なし				*/
/*--------------------------------------*/
void
RecordHeadPos( int PadNum )
{
    snakemove[PadNum].SnakeX[Snake.bufidx[PadNum]] = Snake.pos_x[PadNum][0];
    snakemove[PadNum].SnakeY[Snake.bufidx[PadNum]] = Snake.pos_y[PadNum][0];
    snakemove[PadNum].SnakeRotZ[Snake.bufidx[PadNum]] = Snake.rot_z[PadNum][0];

    if((--Snake.bufidx[PadNum]) < 0){
	Snake.bufidx[PadNum] = TAIL_MOVE_BUF-1;
    }
}

/*----------------------------------------------*/
/*  テイルの動き（ヘッドの軌跡を追いかけます）	*/
/*  IN: Padnum	プレイヤーナンバー		*/
/*  RET:なし					*/
/*----------------------------------------------*/
void
UpdateTailPos( int PadNum )
{
    int MaxTail,idx;

    MaxTail = Snake.tailcnt[PadNum];

    for(idx = 1; idx <= MaxTail; idx++){
	if((Snake.bufidx[PadNum] + SUB*idx) > TAIL_MOVE_BUF-1 ){
	    Snake.bufidx_wk[PadNum] = Snake.bufidx[PadNum] + SUB*idx - TAIL_MOVE_BUF;
	}else{
	    Snake.bufidx_wk[PadNum] = Snake.bufidx[PadNum] + SUB*idx;
	}
 
	Snake.pos_x[PadNum][idx] = snakemove[PadNum].SnakeX[Snake.bufidx_wk[PadNum]];
	Snake.pos_y[PadNum][idx] = snakemove[PadNum].SnakeY[Snake.bufidx_wk[PadNum]];
	Snake.rot_z[PadNum][idx] = snakemove[PadNum].SnakeRotZ[Snake.bufidx_wk[PadNum]];
    }
}


/*--------------------------------------*/
/*  打ち出したテイルの表示		*/
/*  IN:	dp	ダイナミックポインタ	*/
/*  RET:なし				*/
/*--------------------------------------*/
void
DrawShotTail( Dynamic* dp )
{
    int idx;

    for(idx = 0; idx < 20; idx++){
	if(mtx_shot[idx].tail_pattern == -1){
	    continue;
	}else{
	    guTranslate(&(dp->shot_trans[idx]),
			mtx_shot[idx].pos_x,
			mtx_shot[idx].pos_y,
			mtx_shot[idx].pos_z
			);
		    
	    guScale(&(dp->shot_scale[idx]),
		    mtx_shot[idx].size_x,
		    mtx_shot[idx].size_y,
		    mtx_shot[idx].size_z
		    );

	    guRotateRPY(&(dp->shot_rotate[idx]),
			mtx_shot[idx].rot_x+90.0,
			mtx_shot[idx].rot_y,
			mtx_shot[idx].rot_z
			);

	
	    /* モデルマトリックスの設定 */
	    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->shot_trans[idx])),
		      G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);

	    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->shot_rotate[idx])),
		      G_MTX_MODELVIEW | G_MTX_MUL | G_MTX_NOPUSH);

	    gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(dp->shot_scale[idx])),
		      G_MTX_MODELVIEW | G_MTX_MUL | G_MTX_NOPUSH);

	    /* アンチエイリアス無し、不透明サーフェース */
	    gDPSetRenderMode(glistp++,G_RM_ZB_OPA_SURF, G_RM_ZB_OPA_SURF2);

	    /* ジオメトリーのクリア、設定 */
	    gSPClearGeometryMode(glistp++,0xFFFFFFFF);
	    gSPSetGeometryMode(glistp++, G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH |
			       G_LIGHTING | G_CULL_BACK);

	    gDPSetCycleType(glistp++, G_CYC_1CYCLE);
	    /* コンバイナの設定 */
	    gDPSetCombineMode(glistp++,G_CC_DECALRGB, G_CC_DECALRGB);

	    /* モデルのディスプレイリスト */
	    switch(mtx_shot[idx].tail_pattern){
	      case 0:
		gSPDisplayList(glistp++,kiyadou1_mdl_model0);
		break;
	      case 1:
		gSPDisplayList(glistp++,kiyadou2_mdl_model0);
		break;
	      case 2:
		gSPDisplayList(glistp++,kiyadow3_mdl_model0);
		break;
	      case 3:
		gSPDisplayList(glistp++,kiyadow4_mdl_model0);
		break;
	      default:
		break;
	    }
	    gDPPipeSync(glistp++);
	}
    }
}


/*------------------------------------------------------*/
/*  ３Ｄスティックの方向にヘッドを向かせる（９０度単位）*/
/*  IN:	PadNum		登録するプレイヤーナンバー	*/
/*  RET:	なし					*/
/*------------------------------------------------------*/
void
ChgHeadDir( int PadNum, int stickx, int sticky )
{
    Snake.head_dir[PadNum] = Atan2f((float)sticky,
				    (float)stickx);

    if(stickx < 0 && sticky == 0){
	Snake.head_dir[PadNum] += 180.0;
    }
    Snake.rot_z[PadNum][0] = Snake.head_dir[PadNum];
}

/*----------------------------------------------*/
/*  ムービーデータを読み込みます		*/
/*  IN:	MovieNum	ムービーのコマ番号	*/
/*      dp		ダイナミックポインタ	*/
/*  RET:なし					*/
/*----------------------------------------------*/
void
ReadMovie( int MovieNum, Dynamic* dp )
{
    u32 r2rlen;
    u32 onecutlen;

    /* ムービーデータの格納されているセグメント長の算出 */
    r2rlen = _moviedataSegmentRomEnd - _moviedataSegmentRomStart;

    /* １コマあたりの長さの算出 */
    onecutlen = r2rlen / 16;

    /* 実際にＲＯＭからＲＤＲＡＭにデータをコピーします */
    nuPiReadRom( (u32)(_moviedataSegmentRomStart + onecutlen * MovieNum),
		(void *)&(dp->MovieBuf[0]),
		onecutlen
		);
}

/*------------------------------*/
/*  画面情報を表示します	*/
/*  IN:	なし			*/
/*  RET:なし			*/
/*------------------------------*/
void
DrawInfo( void )
{
    sprintf(outstring,"TIME:%03llu", LapTime/1000);
    Draw8Font(20,20, TEX_COL_WHITE, 0);

    if(ReplayMode){
	sprintf(outstring,"NOW PLAYING TRACE DATA");
	Draw8Font(20,30, TEX_COL_WHITE, 0);
    }

    if(Pause){
	if(0x30 > (nuScRetraceCounter & 0x30)){
	    sprintf(outstring,"PAUSE");
	    Draw8Font(141,111, TEX_COL_BLACK, 0);

 	    sprintf(outstring,"PAUSE");
	    Draw8Font(140,110, TEX_COL_GREEN, 0);
	}
    }
}


/*------------------------------------------------------------------------------*/
/* 各スネークのテイルの数を数えます（ゲーム終了判定用）				*/
/*  IN:	 ChkStat	チェック内容（タイムアップ用、全てのテイルを獲得した）	*/
/*  RET: 結果	-1:ドロー	0:通常のゲーム終了	1:パーフェクトで勝利	*/
/*     : 外部ワーク Winner	勝利者番号					*/
/*------------------------------------------------------------------------------*/
int
CheckTailNum( int ChkStat )
{
    int idx, TailNumWk = 0;

    if(ChkStat == TIME_UP){
	if(Snake.tailcnt[0] == 5 &&
	   Snake.tailcnt[1] == 5 &&
	   Snake.tailcnt[2] == 5 &&
	   Snake.tailcnt[3] == 5){
	    Winner = -1;
	    return(-1);
	}
	for(idx = 0; idx < 4; idx++){
	    if(TailNumWk <  Snake.tailcnt[idx]){
		TailNumWk = Snake.tailcnt[idx];
		Winner = idx;
	    }
	}
	return(0);
    }else{
	for(idx = 0; idx < 4; idx++){
	    if(Snake.tailcnt[idx] == 20){
		Winner = idx;
		return(1);
	    }
	}
	return(0);
    }
}

/*------------------------------*/
/* メインゲーム部分の各種初期化	*/
/*  IN:	なし			*/
/*  RET:なし			*/
/*------------------------------*/
void
InitGame( void )
{
    InitSnake();
    InitShotTail();
    View = 0.0;
    MovieNumber = 0;
    StartTime = osGetTime();
    NowTime = osGetTime();
    NowPauseTime = 0;
    Pause = 1;
    TraceIdx = 0;
    UpTempo = 0;
}