spout.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "piece.h"

#include "sintable.h"

#define FRAMERATE 50
#define MAX_GRAIN 500

const unsigned char	MATSUMI[] = {
//	 80,  77,  66,  80, 180,   0,   0,   0,   1,   0, 128,   0,  10,   0, 223, 119,
//	160,   0,   0,   0,
	  0,   0,   0,   0,   0,   0,   0,  34,  56,  68,  10,   4,  80, 129, 202,   0,   
    0,   0,   0,   0,   8,   0,   8,  34,  73, 255, 127, 223,	241, 241,  95,   0,
    0,   0,   0,   0,   8,   0,   0,  71,  72, 254,  10,   5,	 67,  17,  68,   0,
    1,   2,  59, 187, 137,  75, 136,  66, 164,  16,  81,  31,  84, 225, 155,   0,
    2,  25,  10, 168, 138,  74,  72, 135,  33, 255,  49,   5,	 97, 177,  78,   0,
    2,  33,  58, 171, 142,  74,  72, 134,  32,  16,  23, 215,	 86,  77, 117,   0,
    2,  33,  34, 170,   9,  74,  73,   2,  73, 255,  49,  21,	176,  33,  78,   0,
    1,  26,  59, 187, 137,  50,  73,   2,  76,  40,  81,  28,	  0, 193, 181,   0,
    0,   0,   0,   0,   0,   0,   0,   2, 245, 199,  23, 211,	240,  33,  12,   0,
    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,	  0,   0,   0,   0
};

typedef struct {
	short x, y;
} SVECTOR;

typedef struct {
	long x, y;
} VECTOR;

typedef struct tagGRAIN {
	struct tagGRAIN	*next;
	struct tagGRAIN	*prev;

	SVECTOR s, v;
	short pos;
	unsigned char color;
} GRAIN;

unsigned char gamePhase, gameover, frstgameover, ulevelcolor;
GRAIN *grainUseLink, *grainFreeLink;

unsigned char vbuff[128 * 88];
unsigned char vbuff2[128 * 128];

GRAIN grain[MAX_GRAIN];
GRAIN *v2g[128 * 128];

SVECTOR box;

VECTOR mPos, mSpeed;
int mR;

int nGrain;

// ALEK
typedef struct {
  unsigned int score,height;
} hiscores;
// ALEK

int timespout = FRAMERATE * 60, score = 0, height = 0, dispscore = 0;
hiscores hiScore[5];
// ALEK int hiScore[2] = {0, 0};
int dispPos, upperLine, rollCount;

void spout(int t, int x, int y);
void sweep(unsigned char c1, unsigned char c2);
void initGrain(void);
GRAIN *allocGrain(void);
GRAIN *freeGrain(GRAIN *current);

void pceAppInit(void)
{
	pceLCDDispStop();
	pceLCDSetBuffer(vbuff);
	pceAppSetProcPeriod(1000 / FRAMERATE);

	memset(vbuff, 0, 128 * 88);

	pceLCDDispStart();

	pceCPUSetSpeed(CPU_SPEED_NORMAL);

	{
		FILEACC fa;
		if(!pceFileOpen(&fa, "spout.sco", FOMD_RD)) {
			pceFileReadSct(&fa, (void *)hiScore, 0, sizeof(hiScore));
			pceFileClose(&fa);
		}
	}

	pcePadSetTrigMode(PP_MODE_SINGLE);

	srand(pceTimerGetCount());
}

void pceAppProc(int cnt)
{
	static int gamePhase = 0, gameover;

	int pad = pcePadGet();

/*	if(	(pad & (PAD_C | TRG_D)) == (PAD_C | TRG_D) ||*/
/*		(pad & (TRG_C | PAD_D)) == (TRG_C | PAD_D)) {*/
	if(pad & (TRG_C)) {
		if(gamePhase >= 2) {
			if(gamePhase == 4)
			{
				gamePhase = 0;
			}
		} else {
			pceAppReqExit(0);
		}
		pad = 0;
	}

	if(gamePhase == 4) {
		if(pad & (TRG_D)) {
			gamePhase = 3;
		}
		return;
	}

	if(!(gamePhase & 1)) {
		if(gamePhase == 0) {
/*
			if(score > hiScore[0] || (score == hiScore[0] && height > hiScore[1])) {
				FILEACC fa;
				hiScore[0] = score;
				hiScore[1] = height;
				if(!pceFileOpen(&fa, "spout.sco", FOMD_WR)) {
					pceFileWriteSct(&fa, (void *)hiScore, 0, 8);
				} else if(!pceFileCreate("spout.sco", 8)) {
					if(!pceFileOpen(&fa, "spout.sco", FOMD_WR)) {
						pceFileWriteSct(&fa, (void *)hiScore, 0, 8);
					}
				}
				pceFileClose(&fa);
			}
*/
			unsigned int i;
			FILEACC fa;
			for (i = 0; i < 5; i++) {
				if (score > hiScore[i].score) {
					unsigned int j;
					for (j = 5; j > i; j--) {
						hiScore[j].score = hiScore[j - 1].score;
						hiScore[j].height = hiScore[j - 1].height;
					}
					hiScore[i].score = score;
					hiScore[i].height = height;
					if(!pceFileOpen(&fa, "spout.sco", FOMD_WR)) {
						pceFileWriteSct(&fa, (void *)hiScore, 0, sizeof(hiScore));
					}
					pceFileClose(&fa);
					break;
				}

			}
		} else {
			score = 0;
			dispscore = 0;
			height = - 58;
			timespout = 60 * FRAMERATE;
		}

		{
			int i;
			for(i = 0; i < 128 * 128; i ++) {
				v2g[i] = NULL;
			}
			initGrain();
			nGrain = 0;
		}

		if(gamePhase & 2) {
			memset(vbuff2, 0xd2, 128 * 128);
			memset(vbuff2 + 128 * 0, 0, 128 * 78);
			memset(vbuff2 + 128 * (128 - 32), 0, 128 * 32);
		} else {
			memset(vbuff2, 0, 128 * 128);
		}

		memset(vbuff, 0, 128 * 88);

		{
			int i;
			unsigned char *pC;

			pC = vbuff2;
			for(i = 0; i < 128; i ++) {
				*pC++ = 0x0b;
				*pC++ = 0x0b;
				*pC++ = 0x0b;
				*pC++ = 0x0b;
				pC += 128 - 8;
				*pC++ = 0x0b;
				*pC++ = 0x0b;
				*pC++ = 0x0b;
				*pC++ = 0x0b;
			}
		}

		mPos.x = 40 * 256;
		mPos.y = 0 * 256;
		mSpeed.x = 0;
		mSpeed.y = 0;
		mR = 256 + (gamePhase & 2) * 224;

		dispPos = 0;
		upperLine = 0;
		gameover = 0;
		rollCount = 0;
		gamePhase ++;

// ALEK
    frstgameover = 0;
// ALEK

		memset(vbuff + 128, 0x03, 128);
		pceFontSetType(2 + 128);
		pceFontSetPos(0, 82);
		if(height > 0) {
			pceFontPrintf("Time:%2d Height:%4d Score:%6d", (timespout + FRAMERATE - 1) / FRAMERATE, height % 10000, score % 1000000);
		} else {
			pceFontPrintf("Time:%2d Height:   0 Score:%6d", (timespout + FRAMERATE - 1) / FRAMERATE, score % 1000000);
		}
		pceFontSetType(0);
	}

	if((pad & TRG_D) && gamePhase == 3 && gameover == 0) {
		pceFontSetType(2 + 128);
		pceFontSetPos(64 - 7 * 4 / 2, 28);
		pceFontPrintf(" pause ");
		pceFontSetType(0);

		// fill the empty spaces between the text lines below with white bars for better readability
		pceFontSetType(2 + 128);
		pceFontSetPos(64 - 19 * 4 / 2, 36);
		pceFontPrintf("                   ");
		pceFontSetType(0);

		pceFontSetType(2 + 128);
		pceFontSetPos(64 - 19 * 4 / 2, 41);
		pceFontPrintf("                   ");
		pceFontSetType(0);

		pceFontSetType(2 + 128);
		pceFontSetPos(64 - 19 * 4 / 2, 46);
		pceFontPrintf("                   ");
		pceFontSetType(0);

		pceFontSetType(2 + 128);
		pceFontSetPos(64 - 19 * 4 / 2, 38);
		pceFontPrintf(" START  - continue ");
		pceFontSetType(0);

		pceFontSetType(2 + 128);
		pceFontSetPos(64 - 19 * 4 / 2, 45);
		pceFontPrintf(" SELECT - exit     ");
		pceFontSetType(0);

		gamePhase = 4;

		pceLCDTrans();
		return;
	}

	if(gamePhase & 2) {
		if(gameover == 0) {	
			if((pad & PAD_RI)) {
				mR = (mR - 16) & 1023;
			} else if((pad & PAD_LF)) {
				mR = (mR + 16) & 1023;
			}
			if((pad & (PAD_A | PAD_B))) {
				mSpeed.x -= sintable[(256 + mR) & 1023] / 128;
				mSpeed.y += sintable[mR] / 128;
			}
			mSpeed.y += 8;

			if(mSpeed.x < -256 * 4) {
				mSpeed.x = -256 * 4;
			} else if(mSpeed.x > 256 * 4) {
				mSpeed.x = 256 * 4;
			}
			if(mSpeed.y < -256 * 4) {
				mSpeed.y = -256 * 4;
			} else if(mSpeed.y > 256 * 4) {
				mSpeed.y = 256 * 4;
			}

			mPos.x += mSpeed.x / 16;
			mPos.y += mSpeed.y / 16;

			if(mPos.x >= 125 * 256) {
				mPos.x = 124 * 256;
				gameover = 1;
			} else if(mPos.x <= 2 * 256) {
				mPos.x = 3 * 256;
				gameover = 1;
			}
			if(mPos.y >= 78 * 256) {
				mPos.y = 77 * 256;
				gameover = 1;
			}

			if(mPos.y < 40 * 256) {
				unsigned char *pC;
				int i, j, w, x1 , x2;
				mPos.y += 256;
				upperLine = (upperLine - 1) & 127;
				height ++;

				if(height > 0) {
					score ++;
					if((height & 127) == 0) {
						score += (timespout + FRAMERATE - 1) / FRAMERATE * 10;
						timespout += 60 * FRAMERATE;
						if(timespout > 99 * FRAMERATE) {
							timespout = 99 * FRAMERATE;
						}
						pceFontSetType(2 + 128);
						pceFontSetPos(4 * 5, 82);
						pceFontPrintf("%2d", (timespout + FRAMERATE - 1) / FRAMERATE);
						pceFontSetType(0);
					}
					pceFontSetType(2 + 128);
					pceFontSetPos(4 * 15, 82);
					pceFontPrintf("%4d", height % 10000);
					pceFontSetType(0);
				}

				if(upperLine == 111 && height > 0) {
					unsigned long *pL;
					pL = (unsigned long *)(vbuff2 + 128 * 108 + 4);
					while(pL < (unsigned long *)(vbuff2 + 128 * 109 - 4)) {
						*pL++ = 0;
					}
					pL += 2;
					while(pL < (unsigned long *)(vbuff2 + 128 * 110 - 4)) {
						*pL++ = 0xd3d3d3d3;
					}
					pL += 2;
					while(pL < (unsigned long *)(vbuff2 + 128 * 111 - 4)) {
						*pL++ = 0;
					}
// ALEK
				  // Change color ...
				  ulevelcolor++;
				  if (ulevelcolor>8) ulevelcolor=0;
				  pltTbl[2].r=pltTbl[8+ulevelcolor].r;pltTbl[2].g=pltTbl[8+ulevelcolor].g;pltTbl[2].b=pltTbl[8+ulevelcolor].b;
				  //SDL_SetColors(video, &pltTbl[8+ulevelcolor], 2, 1);
				  //SDL_SetColors(layer, &pltTbl[8+ulevelcolor], 2, 1);
// ALEK
				}

				box.x = 20 - (height + 40) / 64;
				if(box.x < 4) {
					box.x = 4;
				}
				box.y = 20 - (height + 40) / 64;
				if(box.y < 4) {
					box.y = 4;
				}

				for(j = 0; j < 1; j ++) {
					int x, y;
					x = 4 + (rand() % box.x);
					y = 4 + (rand() % box.y);
					pC = vbuff2 + ((upperLine - 20 - (rand() & 7)) & 127) * 128;
					x1 = 4 + (rand() % (120 - x));
					x2 = x;
					i = y;
					while(i > 0) {
						if(pC < vbuff2) {
							pC += 128 * 128;
						}
						pC += x1;
						w = x2;
						while(w > 0) {
							*pC++ = 0;
							w --;
						}
						pC -= x1 + x2 + 128;
						i --;
					}
				}

				sweep(0x13, 0xd2);
			}
		}
	} else {
		mPos.x = 7 * 256;
		mPos.y = 60 * 256;
		mR = 0;

		if((rollCount & 7) == 0) {
			int i, j;

			if((upperLine & 31) == 0) {
				unsigned long *pL;
				pceLCDSetBuffer(vbuff2 + ((upperLine - 24) & 127) * 128);
				pceFontSetBkColor(0);

				switch(upperLine / 32) {
					case 0:
						pL = (unsigned long *)(vbuff2 + 12 + ((upperLine - 24) & 127) * 128);
						for(i = 0; i < 16; i ++) {
							for(j = 0; j < 26 / 2; j ++) {
								*pL = 0x91919191;
								pL += 2;
							}
							if((i & 7) == 3) {
								pL += 7;
							} else if((i & 7) == 7) {
								pL += 5;
							} else {
								pL += 6;
							}
						}

						pceFontSetTxColor(0x03);
						pceFontSetType(1 + 128);
						pceFontSetPos(64 - 4 * 5, 0);
						pceFontPrintf("spout");
						break;

					case 2:
						pceFontSetTxColor(0xc3);
						pceFontSetType(2 + 128);
/*						
						pceFontSetPos(118 - 20 * 4, 0);
						pceFontPrintf("    height: %8d", hiScore[1] % 1000000);
						pceFontSetPos(118 - 20 * 4, 6);
						pceFontPrintf("high-score: %8d", hiScore[0] % 1000000);*/
						  for (i=0;i<5;i++) {
							pceFontSetPos(118 - 28 * 4, i*6);
							pceFontPrintf("#%1d sc: %8d hgt: %8d", i+1,hiScore[i].score % 1000000,hiScore[i].height % 1000000);
						  }  
						break;

					case 1:
						{
							const unsigned char *pS = MATSUMI;
							unsigned char *pD = vbuff2 + ((upperLine - 16) & 127) * 128;
							for(i = 0; i < 128 / 8 * 10; i ++) {
								unsigned char t = *pS++;
								for(j = 0; j < 8; j ++) {
									if(t & 0x80) {
										*pD = 0xc3;
									}
									pD ++;
									t <<= 1;
								}
							}
						}
						break;
				}

				pceFontSetType(0);
				pceFontSetTxColor(0x03);
				pceFontSetBkColor(0);

				pceLCDSetBuffer(vbuff);
			}
			upperLine = (upperLine - 1) & 127;

			sweep(0x13, 0x00);
		}
	}

	rollCount ++;

	{
		static int gx[] = {-2, 2, -1, 1, 0};
		int r, t;

		r = rand() & 3;
		t = gx[r]; gx[r] = gx[r + 1]; gx[r + 1] = t;
		if(gamePhase & 2) {
			if(gameover == 0 && (pad & (PAD_A | PAD_B))) {
				int i, t, x, y;
				for(i = 0; i < 5; i ++) {
					t = mPos.x / 256 + gx[i] + ((mPos.y / 256 - 1 + abs(gx[i]) + dispPos) & 127) * 128;
					x = mSpeed.x / 16 + sintable[(256 + mR) & 1023] / 8;
					y = mSpeed.y / 16 - sintable[mR] / 8;
					spout(t, x, y);
				}
			}
		} else {
			int i, t;
			for(i = -1; i <= 2; i ++) {
				t = 7 + i + ((60 - 1 + dispPos) & 127) * 128;
				spout(t, 512, -384);
			}
		}
	}

	{
		GRAIN *pG, *pG2;
		SVECTOR svt;

		pG = grainUseLink;
		while(pG) {
			int f = 0;
			unsigned char *c;

			pG->v.y += 8;

			pG->s.x += pG->v.x;
			pG->s.y += pG->v.y;

			*(vbuff2 + pG->pos) = 0;
			*(v2g + pG->pos) = NULL;

			if(pG->s.y >= 256) {
				do {
					pG->s.y -= 256;
					pG->pos = (pG->pos + 128) & 16383;
					c = (vbuff2 + pG->pos);

					if(*c) {
						if(*c & 0x04) {
							int r;
							pG2 = *(v2g + pG->pos);
							r = 31 - (rand() & 63);
							svt = pG->v;
							pG->v = pG2->v;
							pG2->v = svt;
							pG->v.x += r;
							pG2->v.x -= r;
						} else {
							pG->v.y = -pG->v.y / 2;
							pG->v.x += 15 - (rand() & 31);
							if(*c & 0xc0) {
								*c -= 0x40;
								if(!(*c & 0xc0)) {
									*c = 0;
								}
							}
							if(pG->color & 0xc0) {
								pG->color -= 0x40;
							} else {
								pG->color = 0;
								f = 1;
							}
						}
						pG->pos = (pG->pos - 128) & 16383;
						break;
					}
				} while(pG->s.y >= 256);
			} else {
				while(pG->s.y <= -256) {
					pG->s.y += 256;
					pG->pos = (pG->pos - 128) & 16383;
					c = (vbuff2 + pG->pos);

					if(*c) {
						if(*c & 4) {
							pG2 = *(v2g + pG->pos);
							svt = pG->v;
							pG->v = pG2->v;
							pG2->v = svt;
						} else {
							pG->v.y = -pG->v.y / 2;
							if(*c & 0xc0) {
								*c -= 0x40;
								if(!(*c & 0xc0)) {
									*c = 0;
								}
							}
							if(pG->color & 0xc0) {
								pG->color -= 0x40;
							} else {
								pG->color = 0;
								f = 1;
							}
						}
						pG->pos = (pG->pos + 128) & 16383;
						break;
					}
				}
			}

			if(pG->s.x >= 256) {
				do {
					pG->s.x -= 256;
					pG->pos = (pG->pos + 1) & 16383;
					c = (vbuff2 + pG->pos);

					if(*c) {
						if(*c & 4) {
							pG2 = *(v2g + pG->pos);
							svt = pG->v;
							pG->v = pG2->v;
							pG2->v = svt;
						} else {
							pG->v.x = -pG->v.x / 2;
							if(*c & 0xc0) {
								*c -= 0x40;
								if(!(*c & 0xc0)) {
									*c = 0;
								}
							}
							if(pG->color & 0xc0) {
								pG->color -= 0x40;
							} else {
								pG->color = 0;
								f = 1;
							}
						}
						pG->pos = (pG->pos - 1) & 16383;
						break;
					}
				} while(pG->s.x >= 256);
			} else {
				while(pG->s.x <= -256) {
					pG->s.x += 256;
					pG->pos = (pG->pos - 1) & 16383;
					c = (vbuff2 + pG->pos);

					if(*c) {
						if(*c & 4) {
							pG2 = *(v2g + pG->pos);
							svt = pG->v;
							pG->v = pG2->v;
							pG2->v = svt;
						} else {
							pG->v.x = -pG->v.x / 2;
							if(*c & 0xc0) {
								*c -= 0x40;
								if(!(*c & 0xc0)) {
									*c = 0;
								}
							}
							if(pG->color & 0xc0) {
								pG->color -= 0x40;
							} else {
								pG->color = 0;
								f = 1;
							}
						}
						pG->pos = (pG->pos + 1) & 16383;
						break;
					}
				}
			}

			if(f) {
				*(vbuff2 + pG->pos) = pG->color;
				nGrain --;
				*(v2g + pG->pos) = NULL;
				pG = freeGrain(pG);
			} else {
				*(vbuff2 + pG->pos) = pG->color;
				*(v2g + pG->pos) = pG;
				pG = pG->next;
			}
		}
	}

	dispPos = upperLine;

	{
		unsigned long *pL, *pL2, *pLe;
		pL = (unsigned long *)(vbuff + 2 * 128);
		pL2 = (unsigned long *)(vbuff2 + dispPos * 128);

		pLe = pL2 + 128 * 78 / 4;
		if(pLe > (unsigned long *)(vbuff2 + 128 * 128)) {
			pLe = (unsigned long *)(vbuff2 + 128 * 128);
		}

		while(pL2 < pLe) {
			//ALEK *pL = *pL2 & 0x03030303;
      *pL = *pL2 & 0x07070707;
			pL ++;
			pL2 ++;
		}

		pL2 = (unsigned long *)(vbuff2);
		while(pL < (unsigned long *)(vbuff + 128 * (78 + 2))) {
			//ALEK *pL = *pL2 & 0x03030303;
			*pL = *pL2 & 0x07070707;
			pL ++;
			pL2 ++;
		}
	}

	{
		unsigned char *pC;
		pC = vbuff2 + mPos.x / 256 + ((mPos.y / 256 + dispPos) & 127) * 128;
		if(*pC != 0 && (*pC & 4) == 0) {
			gameover = *pC;
		}
	}

	{
		static int gPhase = 0;
		unsigned char *pC;
		int i, x, y;
		if(gameover == 0 && (gamePhase & 2)) {
			x = mPos.x + sintable[(256 + mR) & 1023] * gPhase / 64;
			y = mPos.y - sintable[mR] * gPhase / 64;
			for(i = 0; i < 3; i ++) {
				if(y >= 78 * 256) {
					break;
				}
				*(vbuff + x / 256 + (y / 256 + 2) * 128) = 3;
				x += sintable[(256 + mR) & 1023] / 16;
				y -= sintable[mR] / 16;

				if(y >= 78 * 256) {
					break;
				}
				*(vbuff + x / 256 + (y / 256 + 2) * 128) = 3;
				x += sintable[(256 + mR) & 1023] / 16;
				y -= sintable[mR] / 16;

				if(y >= 78 * 256) {
					break;
				}
				*(vbuff + x / 256 + (y / 256 + 2) * 128) = 3;
				x += sintable[(256 + mR) & 1023] * 2 / 16;
				y -= sintable[mR] * 2 / 16;
			}
			gPhase = (gPhase + 1) & 15;
		}

		pC = vbuff + mPos.x / 256 + (mPos.y / 256 + 2) * 128;
		*(pC - 129) = 0x03;
		*(pC - 128) = 0x03;
		*(pC - 127) = 0x03;
		*(pC - 1) = 0x03;
		*pC = 0x00;
		*(pC + 1) = 0x03;
		*(pC + 127) = 0x03;
		*(pC + 128) = 0x03;
		*(pC + 129) = 0x03;
	}	
	if(gamePhase == 1) {
		// ALEK if(pad & (TRG_A | TRG_B)) {
		if(pad & TRG_ST) {
			gamePhase = 2;
		}
	} else if(gameover) {
//ALEK		if(pad & (TRG_A | TRG_B)) {
// ALEK			gamePhase = 0;
// ALEK		}
		if( pad & TRG_ST ) {
		  gamePhase = 0;
		  pltTbl[2].r = 96; pltTbl[2].g = 96; pltTbl[2].b = 96;
		  //SDL_SetColors(video, &pltTbl[2], 2, 1);
		  //SDL_SetColors(layer, &pltTbl[2], 2, 1);
		  ulevelcolor = 0;
		}
// ALEK
	}

	if((gamePhase & 2) && timespout && gameover == 0) {
		timespout --;
		if((timespout % FRAMERATE) == 0) {
			pceFontSetType(2 + 128);
			pceFontSetPos(4 * 5, 82);
			pceFontPrintf("%2d", (timespout + FRAMERATE - 1) / FRAMERATE);
			pceFontSetType(0);
		}
		if(timespout == 0) {
			gameover = 1;
		}
	}

	if(dispscore < score) {
		dispscore ++;
		if(dispscore < score) {
			dispscore ++;
		}
		pceFontSetType(2 + 128);
		pceFontSetPos(4 * 26, 82);
		pceFontPrintf("%6d", dispscore % 1000000);
		pceFontSetType(0);
	}

	if(gamePhase == 3 && gameover != 0) {
// ALEK
    if (!frstgameover) {
		frstgameover=1;
    }
// ALEK
		pceFontSetType(2 + 128);
		pceFontSetPos(64 - 11 * 4 / 2, 33);
//ALEK		pceFontPrintf(" game over ");
		pceFontPrintf(" GAME OVER ");

// ALEK
		pceFontSetPos(64 - 11 * 4 / 2, 43);
		pceFontPrintf("PRESS START");
// ALEK
 
		pceFontSetType(0);
	}

	pceLCDTrans();
}


void pceAppExit( void )
{
	pceCPUSetSpeed(CPU_SPEED_NORMAL);
	
	// Free memory
	SDL_FreeSurface(video);
	
	// Free memory
	SDL_QuitSubSystem(SDL_INIT_VIDEO);
}

void spout(int t, int x, int y)
{
	if(*(vbuff2 + t) == 0) {
		if(nGrain < MAX_GRAIN) {
			GRAIN *pG = allocGrain();

			pG->v.x = x;
			pG->v.y = y;
			pG->s.x = 0;
			pG->s.y = 0;

			pG->color = (2 + (rand() & 1)) + 4 + 64 * 3;

			pG->pos = t;
			*(vbuff2 + t) = pG->color;
			v2g[t] = pG;
			nGrain ++;
		}
	}
}

void sweep(unsigned char c1, unsigned char c2)
{
	int i;

	unsigned char *pC = vbuff2 + 4 + 128 * ((upperLine + 77) & 127);
	for(i = 0; i < 120; i ++) {
		if(*pC & 4) {
			GRAIN **ppG;
			ppG = v2g + (int)(pC - vbuff2);
			freeGrain(*ppG);
			*ppG = NULL;
			nGrain --;
		}
		*pC++ = c1;
	}

	pC += 8;
	if(pC >= vbuff2 + 128 * 128) {
		pC -= 128 * 128;
	}

	for(i = 0; i < 120; i ++) {
		*pC++ = c2;
	}
}

void initGrain(void)
{
	int i;

	for(i = 0; i < MAX_GRAIN - 1; i ++) {
		grain[i].next = &grain[i + 1];
	}
	grain[i].next = NULL;

	grainFreeLink = grain;
	grainUseLink = NULL;

	return;
}

GRAIN *allocGrain(void)
{
	GRAIN *current = grainFreeLink;

	if(current) {
		grainFreeLink = current->next;

		current->next = grainUseLink;
		current->prev = NULL;
		if(current->next) {
			current->next->prev = current;
		}
		grainUseLink = current;
	}

	return current;
}

GRAIN *freeGrain(GRAIN *current)
{
	GRAIN *next = current->next;

	if(next) {
		next->prev = current->prev;
	}
	if(current->prev) {
		current->prev->next = next;
	} else {
		grainUseLink = next;
	}

	current->next = grainFreeLink;
	grainFreeLink = current;

	return next;
}