/* ---------------------------------------------------------------------
** Project:	Tetixx	(a Tetris clone)
** File:		options.c
** Date:	11.03.1999
** Autor:	Robert Jurziga
*/

#include <libps.h>
#include <cntrl.h>
#include "tetixx.h"



// ---------------------------------------------------------------------
// P R O T O T Y P E S
// ---------------------------------------------------------------------
void DoOptions();
static void _prepare();
static void OptionsVSync();
static void _ComeUp();
static void _Select_OPTIONS();
static void _GoDown();
static void _FadeOptions();
static void _AdjustScreen();
static int _WhichMemCard();
static void _AccessMemoryCard(int card);




// ---------------------------------------------------------------------
// V A R I A B L E S
// ---------------------------------------------------------------------
static int _ActiBuf;
static short opt_choise;
static int cardn = 0;
static GsSPRITE *ctrlsprite;
static short ready=0;
static short sfxflag=0;
static unsigned long adjustdelay;
static short adjustdelaycount;



/* ---------------------------------------------------------------------
// Function:	DoOptions
// Description:	Options programm flow.
*/

void DoOptions()
{
	_prepare();
	_ComeUp();
	ready=1;
	_Select_OPTIONS();
	ready=0;
	_GoDown();
}






/* ---------------------------------------------------------------------
// Function:	_Select_OPTIONS
// Description:	Handle the options selector Screen.
*/

static
void _Select_OPTIONS()
{
short buttondown=0;

	opt_choise = 0;
	sfxflag = 0;
		
	while (1)
		{
//		if (PadBits & PAD_Select) dumpScreen(0, 0, 511, 256);
		if (PAD_Triangle & PadBits) {
			SsUtKeyOn(ChooseSoundVabID, 0, SFX_GO_BACK, 50, 0, 127, 127);
			break;
			}
		if ((PAD_Cross & PadBits))
			{
			switch (opt_choise)
				{
				case 0:
					{
					if (!sfxflag) {
						sfxflag ^=1;
						SsUtKeyOn(ChooseSoundVabID, 0, SFX_SELECT, 50, 0, 127, 127);
						}
					ctrlsprite = &SelCtrlAdjustSprite;
					_AdjustScreen();
					break;
					}
				case 1:
				case 2:
					{
					if (!sfxflag) {
						sfxflag ^=1;
						SsUtKeyOn(ChooseSoundVabID, 0, SFX_SELECT, 50, 0, 127, 127);
						}
					ctrlsprite = &SelCtrlCardSprite;
					cardn = _WhichMemCard();
					if (cardn) _AccessMemoryCard(cardn);
					}
				}
			}
		else
			{
			sfxflag=0;
			ctrlsprite = &SelCtrlBackSprite;	
			if (!buttondown)
				{
				if (PAD_Down & PadBits)
					{
					buttondown^=1;
					opt_choise++;
					if (opt_choise > 2)
						opt_choise = 2;
					else
						SsUtKeyOn(ChooseSoundVabID, 0, SFX_HIHAT, 50, 0, 127, 127);
					}
				if (PAD_Up & PadBits)
					{
					buttondown^=1;
					if (opt_choise) {
						SsUtKeyOn(ChooseSoundVabID, 0, SFX_HIHAT, 50, 0, 127, 127);
						opt_choise--;
						}
					}
				}
			else
				{
				if (!(PadBits & 0xffff)) buttondown^=1;
				}
			}
			
		_FadeOptions();

		OptionsVSync();
		}
}






/* ---------------------------------------------------------------------
// Function:	_FadeOptions
// Description:	Do same effect like in the main selector screen.
*/

static
void _FadeOptions()
{
short i=0;

	if (i != opt_choise)
		{
		if (opt_AdjustScreenSprite.r != 48)
			{
			opt_AdjustScreenSprite.r = opt_AdjustScreenSprite.g = opt_AdjustScreenSprite.b -= 4;
			}
		}
	else
		{
		opt_AdjustScreenSprite.r = opt_AdjustScreenSprite.g = opt_AdjustScreenSprite.b = 128;
		}
	i++;
	
	if (i != opt_choise)
		{
		if (opt_LoadSprite.r != 48)
			{
			opt_LoadSprite.r = opt_LoadSprite.g = opt_LoadSprite.b -= 4;
			}
		}
	else
		{
		opt_LoadSprite.r = opt_LoadSprite.g = opt_LoadSprite.b = 128;
		}
	i++;
	
		if (i != opt_choise)
		{
		if (opt_SaveSprite.r != 48)
			{
			opt_SaveSprite.r = opt_SaveSprite.g = opt_SaveSprite.b -= 4;
			}
		}
	else
		{
		opt_SaveSprite.r = opt_SaveSprite.g = opt_SaveSprite.b = 128;
		}
}







/* ---------------------------------------------------------------------
// Function:	_GoDown
// Description:	Just add to Y.
*/

static
void _GoDown()
{
	while (SelOptionsSprite.y != 260)
		{
		SelOptionsSprite.y+=8;
		opt_AdjustScreenSprite.y+=8;
		opt_LoadSprite.y+=8;
		opt_SaveSprite.y+=8;
		OptionsVSync();
		}
}







/* ---------------------------------------------------------------------
// Function:	_ComeUP
// Description:	Just sub form Y.
*/

static
void _ComeUp()
{

	while (SelOptionsSprite.y != 116)
		{
		SelOptionsSprite.y-=8;
		opt_AdjustScreenSprite.y-=8;
		opt_LoadSprite.y-=8;
		opt_SaveSprite.y-=8;
		OptionsVSync();
		}
}








/* ---------------------------------------------------------------------
// Function:	_prepare
// Description:	Prepare the options sprites to come.
*/

static
void _prepare()
{
int yoffset = 256+4;

	SelOptionsSprite.y = yoffset;
	SelOptionsSprite.r = SelOptionsSprite.g = SelOptionsSprite.b = 128;
	yoffset+=48;
	
	opt_AdjustScreenSprite.y = yoffset;
	opt_AdjustScreenSprite.x = (512-256)>>1;
	opt_AdjustScreenSprite.r = opt_AdjustScreenSprite.g = opt_AdjustScreenSprite.b = 128;
	yoffset+=28;
	
	opt_LoadSprite.y = yoffset;
	opt_LoadSprite.x = (512-256)>>1;
	opt_LoadSprite.r = opt_LoadSprite.g = opt_LoadSprite.b = 128;
	yoffset+=28;

	opt_SaveSprite.y = yoffset;
	opt_SaveSprite.x = (512-256)>>1;
	opt_SaveSprite.r = opt_SaveSprite.g = opt_SaveSprite.b = 128;

	SelCtrlBackSprite.x = 512-76;				// 76
	SelCtrlBackSprite.y = 256-56;				// 56
	SelCtrlBackSprite.r = SelCtrlBackSprite.g = SelCtrlBackSprite.b = 192;
	
	SelCtrlAdjustSprite.x = 512 - 84;
	SelCtrlAdjustSprite.y = 256 - 48;
	SelCtrlAdjustSprite.r = SelCtrlAdjustSprite.g = SelCtrlAdjustSprite.b = 192;
	
	SelCtrlCardSprite.x = 512 - 68;
	SelCtrlCardSprite.y = 256 - 48;
	SelCtrlCardSprite.r = SelCtrlCardSprite.g = SelCtrlCardSprite.b = 192;

	opt_Card1LoadSprite.x = 512 - 68;
	opt_Card1LoadSprite.y = 256 - 48;
	opt_Card1LoadSprite.r = opt_Card1LoadSprite.g = opt_Card1LoadSprite.b = 192;
	opt_Card1SaveSprite.x = 512 - 68;
	opt_Card1SaveSprite.y = 256 - 48;
	opt_Card1SaveSprite.r = opt_Card1SaveSprite.g = opt_Card1SaveSprite.b = 192;
	opt_Card1ErrorSprite.x = 512 - 68;
	opt_Card1ErrorSprite.y = 256 - 48;
	opt_Card1ErrorSprite.r = opt_Card1ErrorSprite.g = opt_Card1ErrorSprite.b = 192;

	opt_Card2LoadSprite.x = 512 - 68;
	opt_Card2LoadSprite.y = 256 - 48;
	opt_Card2LoadSprite.r = opt_Card2LoadSprite.g = opt_Card2LoadSprite.b = 192;
	opt_Card2SaveSprite.x = 512 - 68;
	opt_Card2SaveSprite.y = 256 - 48;
	opt_Card2SaveSprite.r = opt_Card2SaveSprite.g = opt_Card2SaveSprite.b = 192;
	opt_Card2ErrorSprite.x = 512 - 68;
	opt_Card2ErrorSprite.y = 256 - 48;
	opt_Card2ErrorSprite.r = opt_Card2ErrorSprite.g = opt_Card2ErrorSprite.b = 192;

}







/* ---------------------------------------------------------------------
** Function:	OptionsVSync
** Discription:	Display the basic sprites like background and the.
** 				tetixx logo.
*/

static
void OptionsVSync()
{
unsigned char mask;

	_ActiBuf = GsGetActiveBuff();
	PadBits=(~(*(pport0+2) | *(pport0+3) << 8 ));
	mask = *(pport0+1) >> 4;
	if (*pport0 == 0xff || mask != 0x4)
			InsertStandardController(&ThemeMod);
		
	GsSetWorkBase((PACKET*)GPU_WorkArea[_ActiBuf]);
	GsClearOt(0, 0, &WorldOT[_ActiBuf]);

	if (ready) GsSortFastSprite(ctrlsprite,&WorldOT[_ActiBuf],12);
	
	GsSortFastSprite(&SelOptionsSprite,&WorldOT[_ActiBuf],13);	
	GsSortFastSprite(&opt_AdjustScreenSprite,&WorldOT[_ActiBuf],13);
	GsSortFastSprite(&opt_LoadSprite,&WorldOT[_ActiBuf],13);
	GsSortFastSprite(&opt_SaveSprite,&WorldOT[_ActiBuf],13);

		
	GsSortFastSprite(&BGLeft,&WorldOT[_ActiBuf],15);		// render background
	GsSortFastSprite(&BGRight,&WorldOT[_ActiBuf],15);
	GsSortFastSprite(&TXRight,&WorldOT[_ActiBuf],14);		// render tetixx logo 
	GsSortFastSprite(&TXLeft,&WorldOT[_ActiBuf],14);

	PlayYXM(&ThemeMod);	
	DrawSync(0);
	VSync(0);
	GsSwapDispBuff();
	GsSortClear(0x0, 0x0, 0x0, &WorldOT[_ActiBuf]);
	GsDrawOt(&WorldOT[_ActiBuf]);
}






/* ---------------------------------------------------------------------
** Function:	_AdjustScreen
** Discription:	Here is the the screen moving routine is done
**
*/

static
void _AdjustScreen()
{
	if(PAD_Left & PadBits) {
		if (adjustdelay & PAD_Left) {
			adjustdelaycount++;
			if (adjustdelaycount == 3) {
				adjustdelay^=PAD_Left;
				adjustdelaycount=0;
				}
			}
		else {
			adjustdelay|=PAD_Left;
			if (ScrXOff) {
				ScrXOff--;
				SsUtKeyOn(ChooseSoundVabID, 0, SFX_SHIFT, 46, 0, 127, 127);
				}
			}
		}
	else
		adjustdelay&=~PAD_Left;
		
		
	if(PAD_Right & PadBits) {
		if (adjustdelay & PAD_Right) {
			adjustdelaycount++;
			if (adjustdelaycount == 3) {
				adjustdelay&=~PAD_Right;
				adjustdelaycount=0;
				}
			}
		else {
			adjustdelay|=PAD_Right;
			if (ScrXOff < 32) {
				ScrXOff++;
				SsUtKeyOn(ChooseSoundVabID, 0, SFX_SHIFT, 48, 0, 127, 127);
				}
			}
		}
	else 
		adjustdelay&=~PAD_Right;

		
		
	if(PAD_Up & PadBits) {
		if (adjustdelay & PAD_Up) {
			adjustdelaycount++;
			if (adjustdelaycount == 3) {
				adjustdelay&=~PAD_Up;
				adjustdelaycount=0;
			}
		}
		else {
			adjustdelay|=PAD_Up;
			if (ScrYOff) {
				ScrYOff--;
				SsUtKeyOn(ChooseSoundVabID, 0, SFX_SHIFT, 50, 0, 127, 127);
				}
			}
		}
	else
		adjustdelay&=~PAD_Up;
		
		
	if(PAD_Down & PadBits) {
		if (adjustdelay & PAD_Down) {
			adjustdelaycount++;
			if (adjustdelaycount == 3) {
				adjustdelay&=~PAD_Down;
				adjustdelaycount=0;
			}
		}
		else {
			adjustdelay|=PAD_Down;
			if (ScrYOff < 32) {
				ScrYOff++;
				SsUtKeyOn(ChooseSoundVabID, 0, SFX_SHIFT, 52, 0, 127, 127);
				}
			}
		}
	
	else
		adjustdelay&=~PAD_Down;

				
	GsDISPENV.screen.x=ScrXOff;
	GsDISPENV.screen.y=ScrYOff;
}




/* ---------------------------------------------------------------------
** Function:	_WhichMemCard
** Discription:	Determin wich card is prefered to be used
**
*/

static
int _WhichMemCard()
{
	if (PAD_L1 & PadBits) return(1);
	if (PAD_R1 & PadBits) return(2);
	return(0);
}





/* ---------------------------------------------------------------------
** Function:	_AccessMemoryCard
** Discription:	Access to the memory card
**
*/

void _AccessMemoryCard(int card)
{
int x,i;
int whichcard;
long ret;
unsigned short osp;

	osp = StopYXM(&ThemeMod);
	whichcard = card;
	
	x=TestCard(card-1);

	if (opt_choise == 2) card+=2;
	
	switch(card)
		{
		case 1: ctrlsprite = &opt_Card1LoadSprite;
				break;
		case 2: ctrlsprite = &opt_Card2LoadSprite;
				break;
		case 3: ctrlsprite = &opt_Card1SaveSprite;
				break;
		case 4: ctrlsprite = &opt_Card2SaveSprite;
		}
	

	for (i=0; i<15; i++)
		OptionsVSync();

	if (x != 1) {
		switch(card)
			{
			case 1: 
			case 3: ctrlsprite = &opt_Card1ErrorSprite;
					break;
			case 2:
			case 4: ctrlsprite = &opt_Card2ErrorSprite;
					break;
			default:
					break;
			}
		
		for (i=0; i<120; i++) {
			OptionsVSync();
			}
		}

	else
		{
		if (opt_choise == 1) { 
			ret = Load_Tetixx(whichcard-1);
			if (!ret) {
				ctrlsprite = &opt_Card1ErrorSprite;
				for (i=0; i<120; i++)
					OptionsVSync();
				}
			}
		
		if (opt_choise == 2) {
			ret = Save_Tetixx(whichcard-1);
			if (!ret) {
				ctrlsprite = &opt_Card2ErrorSprite;
				for (i=0; i<120; i++)
					OptionsVSync();
				}				
			}

		}

	ResetYXM(&ThemeMod, osp);
	cardn=0;
}