Spout.c

#if 0 /* Not available on Motorola P2K platform. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#endif

#include "Spout.h"
#include "Sintable.h"

#include <mem.h>

#define FRAMERATE 50
#define MAX_GRAIN 500

static 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;

static GRAIN *grainUseLink, *grainFreeLink;

unsigned char *vbuff;
unsigned char *vbuff2;

static GRAIN *grain;
static GRAIN **v2g;

static SVECTOR box;

static VECTOR mPos, mSpeed;
static int mR;

static int nGrain;

static int time = FRAMERATE * 60, score = 0, height = 0, dispscore = 0;
static int hiScore[2] = {0, 0};
static int dispPos, upperLine, rollCount;

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

void pceAppInit(void)
{
#if defined(UIS_HEAP)
	INT32 status;
#endif

#if defined(JAVA_HEAP)
	vbuff = AmMemAllocPointer(SPOUT_WIDTH * SPOUT_HEIGHT);
#elif defined(UIS_HEAP)
	vbuff = uisAllocateMemory(SPOUT_WIDTH * SPOUT_HEIGHT, &status);
#else
	vbuff = suAllocMem(SPOUT_WIDTH * SPOUT_HEIGHT, NULL);
#endif
	memset(vbuff, 0, SPOUT_WIDTH * SPOUT_HEIGHT);

#if defined(JAVA_HEAP)
	vbuff2 = AmMemAllocPointer(SPOUT_WIDTH * SPOUT_WIDTH);
#elif defined(UIS_HEAP)
	vbuff2 = uisAllocateMemory(SPOUT_WIDTH * SPOUT_WIDTH, &status);
#else
	vbuff2 = suAllocMem(SPOUT_WIDTH * SPOUT_WIDTH, NULL);
#endif
	memset(vbuff2, 0, SPOUT_WIDTH * SPOUT_WIDTH);

#if defined(JAVA_HEAP)
	v2g = AmMemAllocPointer(SPOUT_WIDTH * SPOUT_WIDTH * sizeof(GRAIN *));
#elif defined(UIS_HEAP)
	v2g = uisAllocateMemory(SPOUT_WIDTH * SPOUT_WIDTH * sizeof(GRAIN *), &status);
#else
	v2g = suAllocMem(SPOUT_WIDTH * SPOUT_WIDTH * sizeof(GRAIN *), NULL);
#endif
	memset(v2g, 0, SPOUT_WIDTH * SPOUT_WIDTH * sizeof(GRAIN *));

#if defined(JAVA_HEAP)
	grain = AmMemAllocPointer(MAX_GRAIN * sizeof(GRAIN));
#elif defined(UIS_HEAP)
	grain = uisAllocateMemory(MAX_GRAIN * sizeof(GRAIN), &status);
#else
	grain = suAllocMem(MAX_GRAIN * sizeof(GRAIN), NULL);
#endif
	memset(grain, 0, MAX_GRAIN * sizeof(GRAIN));

	pceLCDDispStop();
	pceLCDSetBuffer(vbuff);
	pceAppSetProcPeriod(1000 / FRAMERATE);

	pceLCDDispStart();

	//pceCPUSetSpeed(CPU_SPEED_NORMAL);

	{
		FILEACC fa;
		if(!pceFileOpen(&fa, "spout.sco", FOMD_RD)) {
			pceFileReadSct(&fa, (void *)hiScore, 0, 8);
			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(gamePhase >= 2) {
			gamePhase = 0;
		} else {
			pceAppReqExit(0);
		}
		pad = 0;
	}

	if(gamePhase == 4) {
		if(pad & (TRG_C)) {
			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);
			}
		} else {
			score = 0;
			dispscore = 0;
			height = - 58;
			time = 60 * FRAMERATE;
		}

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

		if(gamePhase & 2) {
			memset((unsigned char *) (vbuff2), 0xd2, 128 * 128);
			memset((unsigned char *) (vbuff2 + 128 * 0), 0, 128 * 78);
			memset((unsigned char *) (vbuff2 + 128 * (128 - 32)), 0, 128 * 32);
		} else {
			memset((unsigned char *) 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 ++;

		memset((unsigned char *) (vbuff + 128), 0x03, 128);
		pceFontSetType(2 + 128);
		pceFontSetPos(0, 82);
		if(height > 0) {
			pceFontPrintf3("time:%2d height:%4d score:%6d", (time + FRAMERATE - 1) / FRAMERATE, height % 10000, score % 1000000);
		} else {
			pceFontPrintf2("time:%2d height:   0 score:%6d", (time + FRAMERATE - 1) / FRAMERATE, score % 1000000);
		}
		pceFontSetType(0);
	}

	if((pad & TRG_C) && gamePhase == 3 && gameover == 0) {
		pceFontSetType(2 + 128);
		pceFontSetPos(64 - 7 * 4 / 2, 33);
		pceFontPrintf(" pause ");
		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 += (time + FRAMERATE - 1) / FRAMERATE * 10;
						time += 60 * FRAMERATE;
						if(time > 99 * FRAMERATE) {
							time = 99 * FRAMERATE;
						}
						pceFontSetType(2 + 128);
						pceFontSetPos(4 * 5, 82);
						pceFontPrintf1("%2d", (time + FRAMERATE - 1) / FRAMERATE);
						pceFontSetType(0);
					}
					pceFontSetType(2 + 128);
					pceFontSetPos(4 * 15, 82);
					pceFontPrintf1("%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;
					}
				}

				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);
						pceFontPrintf1("    height: %8d", hiScore[1] % 1000000);
						pceFontSetPos(118 - 20 * 4, 6);
						pceFontPrintf1("high-score: %8d", hiScore[0] % 1000000);
						pceFontSetPos (6, 18);
						pceFontPrintf ("(c)2023 EXL/Motorola P2K port");
						pceFontSetPos (6, 24);
						pceFontPrintf ("http://github.com/EXL/P2kElfs");
						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) {
			*pL = *pL2 & 0x03030303;
			pL ++;
			pL2 ++;
		}

		pL2 = (unsigned long *)(vbuff2);
		while(pL < (unsigned long *)(vbuff + 128 * (78 + 2))) {
			*pL = *pL2 & 0x03030303;
			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) {
		if(pad & (TRG_A | TRG_B)) {
			gamePhase = 2;
		}
	} else if(gameover) {
		if(pad & (TRG_A | TRG_B)) {
			gamePhase = 0;
		}
	}

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

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

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

	pceLCDTrans();
}

void pceAppExit( void )
{
#if defined(JAVA_HEAP)
	AmMemFreePointer(grain);
	AmMemFreePointer(v2g);
	AmMemFreePointer(vbuff2);
	AmMemFreePointer(vbuff);
#elif defined(UIS_HEAP)
	uisFreeMemory(grain);
	uisFreeMemory(v2g);
	uisFreeMemory(vbuff2);
	uisFreeMemory(vbuff);
#else
	mfree(grain);
	mfree(v2g);
	mfree(vbuff2);
	mfree(vbuff);
#endif
	//pceCPUSetSpeed(CPU_SPEED_NORMAL);
}

static 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 ++;
		}
	}
}

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

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

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

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