////////////////////////////////////////////////////////////////
// action.x
//                               Programed by KYOSKE 1999-2001

#include "action.h"
#include "program/vsp.h"

#define COPYRIGHT "Graphic Designed by NEY\nProgramed by KYOSKE 1999-2000\n"

#define  SCREEN_SIZE   256    // 画面サイズ
#define  SCREEN_HALF   128    // 画面サイズの半分
#define  LIMIT_LEFT  (-184)   // ステージの左端(ワールド座標)
#define  LIMIT_RIGHT   184    // ステージの右端(ワールド座標)
#define  LIMIT_TOP     (-8)   // ステージの上端(ワールド座標)
#define  LIMIT_BOTTOM    0    // ステージの下端(ワールド座標)

#define  SHOT_CLOUD  1

#define  TPF_NONE      0
#define  TPF_RESET     1
#define  TPF_BLACKOUT  2
#define  TPF_FLASH     3

static short idRes;

char *g_ptrBack1;
char *g_ptrBack2;
char *g_ptrVSP;
char *g_ptrPal;
char *g_ptrMdc;
char *g_ptrPdx;

static short g_vx    = 0;
static short g_vy    = 0;
static short g_tpf   = TPF_NONE;
static short g_color = 0;
static short g_quake = OFF;
static short g_palBlack[256];

static FUNC_LIST funclist1[] = {
	OPT_START_ROUND,    OptStartRound,
	VCT_PALETTE,        VctPalette,
	VCT_BLACKOUT,       VctBlackOut,
	VCT_FLASH,          VctFlash,
	VCT_STAGE_DRAW,     VctStageDraw,
	VCT_STAGE_SCROLL,   VctStageScroll,
	VCT_STAGE_SHADOW,   VctStageShadow,
	VCT_STAGE_CLOUD,    VctStageCloud,
	VCT_STAGE_QUAKE,    VctStageQuake,
	END_OF_FUNC
};

int main(int argc, char *argv[]) {
	void *p;
	short i;

	module_startRegistry(argc, argv, COPYRIGHT);

	p = module_getSelf();
	module_setFunction(p, SYS_OPEN,     SysOpen);
	module_setFunction(p, SYS_CLOSE,    SysClose);
	module_setFunction(p, SYS_REGIST,   SysRegist);
	module_setFunction(p, SYS_UNREGIST, SysUnregist);

	module_finishRegistry();
}

void SysOpen(void *p) {
	void *xar;

	// データの読み込み
	idRes = res_loadFile(p, "RESOURCE.XAR");
	xar   = res_getPointer(idRes);

	g_ptrBack1 = res_getXarPointer(xar, "BACK1.GFX");
	g_ptrBack2 = res_getXarPointer(xar, "BACK2.GFX");
	g_ptrVSP   = res_getXarPointer(xar, "CELL.VSP");
	g_ptrPal   = res_getXarPointer(xar, "CELL.PAL");
	g_ptrMdc   = res_getXarPointer(xar, "BGM1.MDC");
	g_ptrPdx   = res_getXarPointer(xar, "BGM.PDX");
}

void SysClose(void *p) {
}

void SysRegist(void *p) {
	short i;

	// 関数の登録
	module_setFunctions(p, funclist1);
	module_setShotFunction(p, SHOT_CLOUD, ShotCloud);

	// スプライトデータの登録
	spr_registVSP(p, g_ptrVSP);

	// パレットデータの登録
	pal_set(p, g_ptrPal, 0, 1);

	// ステージ境界の設定
	pos_setWorldBounds(LIMIT_LEFT, LIMIT_TOP-SCREEN_SIZE, LIMIT_RIGHT, LIMIT_BOTTOM);

	// 暗転パレットの作成
	pal_copyGFX(g_palBlack, g_ptrBack1);
	pal_copyGFX(g_palBlack, g_ptrBack2);
	for (i = 0; i < 256; i++) g_palBlack[i] = (g_palBlack[i]>>1) & 0x7bde;
	bgm_registMDC( g_ptrMdc );
	bgm_registPDX( g_ptrPdx );
}

void SysUnregist(void *p) {
}

void OptStartRound(void *p) {
	g_vx    = 0;
	g_vy    = 0;
	g_tpf   = TPF_RESET;
	g_color = 0;
	g_quake = OFF;
	bgm_play();
}

void VctPalette(void *p) {
	short pal[256];
	short i;

	switch (g_tpf) {
	case TPF_RESET:
		// 背景パレットの復元
		pal_setGFX(g_ptrBack1);
		pal_setGFX(g_ptrBack2);
		g_tpf = TPF_NONE;
		break;
	case TPF_BLACKOUT:
		// 暗転
		pal_setGraphic(g_palBlack, 0, 256);
		g_tpf = TPF_RESET;
		break;
	case TPF_FLASH:
		// フラッシュ
		for (i = 0; i < 256; i++) pal[i] = g_color;
		pal_setGraphic(pal, 0, 256);
		g_tpf = TPF_RESET;
		break;
	}
}

void VctBlackOut(void *p) {
	g_tpf = TPF_BLACKOUT;
}

void VctFlash(void *p, short color) {
	g_tpf   = TPF_FLASH;
	g_color = color;
}

void VctStageDraw(void *p) {
	pal_setGFX(g_ptrBack1);
	pal_setGFX(g_ptrBack2);
	grp_drawGFX(g_ptrBack1, 0);
	grp_drawGFX(g_ptrBack2, 1);
}

void VctStageScroll(void *st, void *p1, void *p2) {
	RECT  *rc1;
	RECT  *rc2;
	POINT *pt;
	short x, y;
	short x1, x2, u1, u2;
	short y1, y2;

	pt  = pos_getWorld();
	x1  = FIXP_I(pos_getX(p1));
	x2  = FIXP_I(pos_getX(p2));
	y1  = FIXP_I(pos_getY(p1));
	y2  = FIXP_I(pos_getY(p2));
	u1  = FIXP_I(pos_getPrevX(p1));
	u2  = FIXP_I(pos_getPrevX(p2));
	rc1 = cell_getFirstRect(p1, cell_get(p1), RECT_TYPE_PUSH);
	rc2 = cell_getFirstRect(p2, cell_get(p2), RECT_TYPE_PUSH);

	/* キャラクタ移動によるスクロール量の計算 */
	x = pt->x;
	y = pt->y;
	if (x1 < (x-64)) {
		if (x1 < u1) x += x1 - u1;
	} else if (x1 > (x+64)) {
		if (x1 > u1) x += x1 - u1;
	}
	if (x2 < (x-64)) {
		if (x2 < u2) x += x2 - u2;
	} else if (x2 > (x+64)) {
		if (x2 > u2) x += x2 - u2;
	}
	if (y1 < y2) {
		y = y1 / 8;
	} else {
		y = y2 / 8;
	}

	/* キャラクタが画面両端にいる場合のスクロール量の補正 */
	if (rc1 != NULL) {
		     if (x-SCREEN_HALF > rc1->left ) x = rc1->left +SCREEN_HALF;
		else if (x+SCREEN_HALF < rc1->right) x = rc1->right-SCREEN_HALF;
	}
	if (rc2 != NULL) {
		     if (x-SCREEN_HALF > rc2->left ) x = rc2->left +SCREEN_HALF;
		else if (x+SCREEN_HALF < rc2->right) x = rc2->right-SCREEN_HALF;
	}

	/* ステージ端によるスクロール量の補正 */
	     if (x < LIMIT_LEFT +SCREEN_HALF) x = LIMIT_LEFT +SCREEN_HALF;
	else if (x > LIMIT_RIGHT-SCREEN_HALF) x = LIMIT_RIGHT-SCREEN_HALF;
	     if (y < LIMIT_TOP   ) y = LIMIT_TOP;
	else if (y > LIMIT_BOTTOM) y = LIMIT_BOTTOM;

	/* 急激な移動を抑制するためのスクロール量補正 */
	if (x > pt->x) {
		if (x - pt->x > g_vx) {
			g_vx++;
			if (g_vx > 0) x = pt->x + g_vx;
		} else {
			if (g_vx > 0) g_vx--;
		}
	} else {
		if (x - pt->x < g_vx) {
			g_vx--;
			if (g_vx < 0) x = pt->x + g_vx;
		} else {
			if (g_vx < 0) g_vx++;
		}
	}
	if (y > pt->y) {
		if (y - pt->y > g_vy) {
			g_vy++;
			if (g_vy > 0) y = pt->y + g_vy;
		} else {
			if (g_vy > 0) g_vy--;
		}
	} else {
		if (y - pt->y < g_vy) {
			g_vy--;
			if (g_vy < 0) y = pt->y + g_vy;
		} else {
			if (g_vy < 0) g_vy++;
		}
	}

	/* ワールド座標の設定 */
	pos_setWorld(x, y);
}

void VctStageShadow(void *st, void *p1, void *p2) {
	static short tbl[8] = { -8, -6, -4, -2, 2, 4, 6, 8 };
	POINT *world;
	POINT *pt;
	short x, y, n;

	/* ワールド座標の取得 */
	world = pos_getWorld();

	/* 影の表示 */
	pt = pos_getCenterPoint(p1, RECT_TYPE_PUSH);
	x  = pt->x - world->x + SCREEN_HALF;
	y  = 208 - world->y;

	n  = FIXP_I(pos_getY(p1));
	if (n < -64) {
		n = VSP_SHADOW3;
	} else if (n < -32) {
		n = VSP_SHADOW2;
	} else {
		n = VSP_SHADOW1;
	}
	spr_setVSP(st, x, y, n, PCG_PAL_STAGE_1|0x20);

	pt = pos_getCenterPoint(p2, RECT_TYPE_PUSH);
	x  = pt->x - world->x + SCREEN_HALF;
	y  = 208 - world->y;

	n  = FIXP_I(pos_getY(p2));
	if (n < -64) {
		n = VSP_SHADOW3;
	} else if (n < -32) {
		n = VSP_SHADOW2;
	} else {
		n = VSP_SHADOW1;
	}
	spr_setVSP(st, x, y, n, PCG_PAL_STAGE_1|0x20);

	/* 背景のスクロール */
	x = world->x;
	y = world->y;
	if (g_quake) {
		y += tbl[xvy_rand() & 7];
		g_quake = OFF;
	}
	scr_setGraphScroll(0, SCREEN_HALF+x,      y   +16);
	scr_setGraphScroll(1, SCREEN_HALF+(x/2), (y/2)+16);
}

void VctStageCloud(void *st, void *p1, short x) {
	shot_allocateModule(st, SHOT_CLOUD, ON, x, 0);
}

void VctStageQuake(void *p) {
	g_quake = ON;
}

int ShotCloud(void *p1, void *p2, short cmd, int param1, int param2) {
	static POINT pt;
	POINT *world;
	void  *st;
	int n, x, y;
	int r = TRUE;

	switch (cmd) {
	case SHOT_CMD_ACTIVE:
		shot_setCounter(p1, 0);
		shot_setState(p1, 0);
		shot_setPalette(p1, 0);
		state_setDrct(p1, DRCT_CENTER);
		pt.x = param1;
		pt.y = 208;
		cell_set(p1, CELL_透明);
		break;
	case SHOT_CMD_MOVE:
		n = shot_getCounter(p1);
		if (n < 18) {
			shot_setCounter(p1, n+1);
		} else {
			shot_sendCommand(p1, p1, SHOT_CMD_INACTIVE, 0, 0);
		}
		break;
	case SHOT_CMD_DRAW:
		world = pos_getWorld();
		n = shot_getCounter(p1);
		x = pt.x - world->x + SCREEN_HALF;
		y = pt.y - world->y;
		if (n < 6) {
			spr_setVSP(p1, x-(n+16), y, VSP_CLOUD1, PCG_PAL_STAGE_1|0x20);
			spr_setVSP(p1, x+(n+16), y, VSP_CLOUD1, PCG_PAL_STAGE_1|PCG_HREV|0x20);
		} else if (n < 12) {
			spr_setVSP(p1, x-(n+16), y, VSP_CLOUD2, PCG_PAL_STAGE_1|0x20);
			spr_setVSP(p1, x+(n+16), y, VSP_CLOUD2, PCG_PAL_STAGE_1|PCG_HREV|0x20);
		} else {
			spr_setVSP(p1, x-(n+16), y, VSP_CLOUD3, PCG_PAL_STAGE_1|0x20);
			spr_setVSP(p1, x+(n+16), y, VSP_CLOUD3, PCG_PAL_STAGE_1|PCG_HREV|0x20);
		}
		break;
	default:
		r = shot_defaultProcess(p1, p2, cmd, param1, param2);
	}
	return r;
}