made files fall gradually, fixed scoring bug, updated README

CHANGELOG.txt

···
  - game end screen now flashes "GAME OVER" instead of just displaying it
  - displayed high score now updates when the game is restarted
  - added clear to exit to controls list in readme
- - changed file removal behavior
+ - overhauled file match, scoring, and removal behavior
+ - made files fall gradually

README.md

···
 
 Support the official release! Check out *EXAPUNKS*, an incredible open-ended programming puzzle game and good introduction to Zachtronics's catalog; *Last Call BBS*, a collection best described as several outstanding games rolled into one; or check out the NES port this is most closely based on on itch.io.
 
+## Installation
+
+Using any linking program (TILP, TI Connect CE, etc), import HACKMTCH.8xg onto your calculator. This program also relies on the standard C library available [here](https://github.com/CE-Programming/libraries/releases). If launching the program displays the error "need libload", try reinstalling that library.
+
 ## How to Play
 
 *HACK\*MATCH* is a match-4 game in the vein of Candy Crush, but (hopefully!) better. Move matching files into groups of 4 to remove them and score points. Files will continue to be added from the top; if they reach the bottom, it's game over!
···
 Program Type: ASM
 
 Size and Variable Usage:
-- RAM: 7360 B
-    - HACKMTCH: 7340 B
+- RAM: 7705 B
+    - HACKMTCH: 7685 B
     - HKMCHDAT: 20 B
 - ARC: 54117 B
     - HKMCHGFX: 54117 B

src/drawing.c

···
 #include "variables.h"
 #include "drawing.h"
 
+#include <debug.h>
+
 unsigned char global_palette[32 + sizeof_grid_palette];
 unsigned char deathStage;
 bool deathFlashOn;
···
 {
 	const unsigned int x = GRID_HOFFSET + col * GRID_SIZE;
 
-	unsigned char y = GRID_VOFFSET;
+	unsigned char y = GRID_VOFFSET - gridMoveOffset;
 	for (unsigned char row = 0; row < MAX_ROWS; row++)
 	{
 		if (files[col][row] != FILE_EMPTY)
 		{
 			// draw a file
-			if (files[col][row] & 0x80) gfx_Sprite_NoClip(fileMatchSprites[files[col][row] & 0x7f], x, y);
-			else if (files[col][row] & 0x10) gfx_Sprite_NoClip(file_locked, x, y);
-			else gfx_Sprite_NoClip(fileSprites[files[col][row]], x, y);
+			if (files[col][row] & 0x80)
+			{
+				if (files[col][row] & 0x08) gfx_Sprite(star_match, x, y);
+				else gfx_Sprite(fileMatchSprites[files[col][row] & 0x7f], x, y);
+			}
+			else if (files[col][row] & 0x10) gfx_Sprite(file_locked, x, y);
+			else gfx_Sprite(fileSprites[files[col][row]], x, y);
 		}
 		else
 		{
 			gfx_SetColor(COLOR_BLACK);
-			gfx_FillRectangle_NoClip(x, y, GRID_SIZE, GRID_SIZE);
+			gfx_FillRectangle(x, y, GRID_SIZE, GRID_SIZE);
 
 			if (col == exaCol)
 			{
···
 				const unsigned char xx = x + DASH_HOFFSET;
 				for (unsigned char yy = y + DASH_VOFFSET; yy < y + GRID_SIZE; yy += DASH_INTERVAL)
 				{
-					gfx_SetPixel(xx, yy);
+					gfx_FillRectangle(xx, yy, DASH_WIDTH, DASH_HEIGHT);
 				}
 			}
 		}
 		y += GRID_SIZE;
 	}
 
-	if (col == exaCol) drawExa(); // else it will have been drawn over a bit
+	// fill in below the grid for partially-lowered files
+	gfx_SetColor(COLOR_BLACK);
+	gfx_FillRectangle(x, y, GRID_SIZE, gridMoveOffset);
+
+	if (col == exaCol)
+	{
+		gfx_SetColor(COLOR_DASH);
+		const unsigned char xx = x + DASH_HOFFSET;
+		for (unsigned char yy = y + DASH_VOFFSET; yy < y + gridMoveOffset; yy += DASH_INTERVAL)
+		{
+			gfx_FillRectangle_NoClip(xx, yy, DASH_WIDTH, DASH_HEIGHT);
+		}
+
+		drawExa(); // else it will have been drawn over a bit
+	}
 }
 
 void clearifySprites(const unsigned char step)
 {
-	unsigned int y = GRID_VOFFSET;
+	unsigned int y = GRID_VOFFSET - gridMoveOffset;
 	for (unsigned char row = 0; row < MAX_ROWS; row++)
 	{
 		unsigned char x = GRID_HOFFSET;
···
 			{
 				if (files[col][row] & 0x08)
 				{
-					if (step == 0) gfx_Sprite_NoClip(star_erase_1, x, y);
-					else gfx_Sprite_NoClip(star_erase_2, x, y);
+					if (step == 0) gfx_Sprite(star_erase_1, x, y);
+					else gfx_Sprite(star_erase_2, x, y);
 				}
 				else
 				{
-					if (step == 0) gfx_Sprite_NoClip(file_erase_1, x, y);
-					else gfx_Sprite_NoClip(file_erase_2, x, y);
+					if (step == 0) gfx_Sprite(file_erase_1, x, y);
+					else gfx_Sprite(file_erase_2, x, y);
 				}
 			}
 
···
 		gfx_BlitBuffer();
 	}
 
-	nextLineTime += clock() - refundTimer;
+	nextMoveTime += clock() - refundTimer;
 }
 
 void drawNumber(const unsigned int x, const unsigned char y, const unsigned int toDraw)

src/main.c

···
 bool isHoldingFile;
 unsigned char heldFile;
 
-clock_t nextLineTime;
+unsigned char gridMoveOffset;
+clock_t nextMoveTime;
 
 unsigned char prevRight, prevLeft, prev2nd, prevAlpha;
 
 bool matched;
 unsigned char starMatches;
 clock_t clearTime;
-unsigned char nextValue;
+unsigned int nextValue;
 
 bool getTargetedFile(unsigned char *output) // each of these returns false on failure
 {
···
 	gfx_SetDrawBuffer();
 #endif
 
-	nextLineTime += clock() - refundTimer;
+	nextMoveTime += clock() - refundTimer;
 
 	return true;
 }
···
 	gfx_SetDrawBuffer();
 #endif
 
-	nextLineTime += clock() - refundTimer;
+	nextMoveTime += clock() - refundTimer;
 
 	return true;
 }
···
 	}
 }
 
-void getNextLineTime()
+void getNextMoveTime()
 {
 	if (score < ROW_INTERVAL_SCALE_END)
 	{
-		nextLineTime = clock() + MAX_NEW_ROW_INTERVAL;
+		nextMoveTime = clock() + MAX_NEW_ROW_INTERVAL / 4;
 
 		if (score > ROW_INTERVAL_SCALE_START)
 		{
-			nextLineTime -= (score - ROW_INTERVAL_SCALE_START) * ROW_INTERVAL_SCALE_FACTOR;
+			nextMoveTime -= (score - ROW_INTERVAL_SCALE_START) * ROW_INTERVAL_SCALE_FACTOR / 4;
 		}
 	}
 	else
 	{
-		nextLineTime = clock() + MIN_NEW_ROW_INTERVAL;
+		nextMoveTime = clock() + MIN_NEW_ROW_INTERVAL / 4;
 	}
 }
 
···
 			break;
 		}
 	}
+
+	// move all the blocks back up so it's not too jarring
+	gridMoveOffset += GRID_SIZE;
 }
 
 void collapseGrid()
···
 	clearTime = clock() + MATCH_TIME;
 }
 
+void clearMarks(const bool toMark)
+{
+	for (unsigned char checkRow = 0; checkRow < MAX_ROWS; checkRow++)
+	{
+		for (unsigned char checkCol = 0; checkCol < NUM_COLS; checkCol++)
+		{
+			if (toMark) files[checkCol][checkRow] &= 0xbf;
+			else if (files[checkCol][checkRow] & 0x40) files[checkCol][checkRow] &= 0x3f;
+		}
+	}	
+}
+
 void checkForMatch()
 {
 	// check for sets to pop and score
···
 				if (numMatchingStars < 2)
 				{
 					// if not, we don't care about it, bc it can't form a set
-					files[col][row] &= 0x7f;
+					clearMarks(false);
 				}
 				else
 				{
+					starMatches += numMatchingStars;
+
 					// if we get here, it does have a match!
 					const unsigned char target = files[col][row] & 0x07;
 					for (unsigned char starRow = 0; starRow < MAX_ROWS; starRow++)
···
 				// find all contiguous matching blocks and their count
 				unsigned char numMatchingBlocks = 0;
 				findMatchRegion(row, col, files[col][row], &numMatchingBlocks);
-				const bool toMark = numMatchingBlocks >= AMOUNT_FILES_TO_MATCH;
 
 				// unmark or cement the matching region
-				for (unsigned char checkRow = 0; checkRow < MAX_ROWS; checkRow++)
-				{
-					for (unsigned char checkCol = 0; checkCol < NUM_COLS; checkCol++)
-					{
-						if (toMark) files[checkCol][checkRow] &= 0xbf;
-						else if (files[checkCol][checkRow] & 0x40) files[checkCol][checkRow] &= 0x3f;
-					}
-				}	
-
+				const bool toMark = numMatchingBlocks >= AMOUNT_FILES_TO_MATCH;
+				clearMarks(toMark);	
 				if (toMark) setClearTime();	
 			}
 		}
···
 	}
 
 	// calculate the score for the matching region
-	unsigned char atBase = nextValue == BASE_BLOCK_VALUE ? AMOUNT_FILES_TO_MATCH : 0;
+	unsigned char atBase = 0;
+	if (nextValue == BASE_BLOCK_VALUE) atBase = AMOUNT_FILES_TO_MATCH;
 	numMatchingBlocks -= starMatches;
 	while (numMatchingBlocks > 0)
 	{
···
 					
 		score += nextValue;
 		numMatchingBlocks--;
+
+		dbg_printf("added block with value %u\n", nextValue);
 	}
 
+	dbg_printf("total score: %u\n", score);
+
 	// tidy up
 	matched = false;
 	starMatches = 0;
···
 
 void updateGrid()
 {
+	clock_t refundTimer = clock();
+
 	// remove the matched blocks and collapse the grid if it's time
 	if (matched && clock() > clearTime)
 	{
···
 	checkForMatch();
 
 	// reset the score if not
-	if (!matched) nextValue = BASE_BLOCK_VALUE;
+	if (!matched)
+	{
+		nextValue = BASE_BLOCK_VALUE;
+
+		// ...and move the grid down if it's time
+		if (clock() > nextMoveTime)
+		{
+			gridMoveOffset -= GRID_SIZE / GRID_MOVE_STEPS;
+			if (gridMoveOffset == 0) addNewRow();
+			getNextMoveTime();
+		}
+	}
 
-	// move the grid down if it's time
-	if (clock() > nextLineTime)
+	// if there is a match, don't move the grid down
+	else 
 	{
-		addNewRow();
-		getNextLineTime();
+		nextMoveTime += clock() - refundTimer;
 	}
 }
 
···
 	}
 
 	// populate the initial grid
-	for (unsigned char i = 0; i < NUM_INITIAL_ROWS; i++)
+	for (unsigned char i = 0; i <= NUM_INITIAL_ROWS; i++)
 	{
 		addNewRow();
 	}
 
+	gridMoveOffset = GRID_SIZE;
+
 	// set and draw initial exa position
 	exaCol = EXA_START_COL;
 	gfx_GetSprite(behindExa, EXA_HOFFSET + EXA_START_COL * GRID_SIZE, EXA_VOFFSET);
 	gfx_TransparentSprite_NoClip(exa_empty, EXA_HOFFSET + EXA_START_COL * GRID_SIZE, EXA_VOFFSET);
 
-	nextLineTime = clock() + MIN_NEW_ROW_INTERVAL;
+	nextMoveTime = clock() + MIN_NEW_ROW_INTERVAL;
 }
 
 bool endGame()
···
 #else
 	gfx_SetDrawBuffer();
 #endif
+
+	// set the clip area so that the grid can be offset
+	gfx_SetClipRegion(0, CLIP_VOFFSET, GFX_LCD_WIDTH, GFX_LCD_HEIGHT);
 
 	// prepare the sketchy combination palette
 	for (unsigned char i = 0; i < sizeof_fixed_palette; i++) global_palette[i] = fixed_palette[i];

src/variables.h

···
 #define GRID_HOFFSET (BG_HOFFSET + 48)
 #define GRID_VOFFSET (BG_VOFFSET + 23)
 #define GRID_SIZE 16
+#define GRID_MOVE_STEPS 4
+#define CLIP_VOFFSET (BG_VOFFSET + 22)
 #define EXA_HOFFSET (BG_HOFFSET + 44)
 #define EXA_VOFFSET (BG_VOFFSET + 193)
 #define EXA_HELD_HOFFSET 4
···
 #define DASH_HOFFSET 8
 #define DASH_VOFFSET 3
 #define DASH_INTERVAL 4
+#define DASH_WIDTH 1
+#define DASH_HEIGHT 1
 #define SCORE_HOFFSET (BG_HOFFSET + 160)
 #define SCORE_VOFFSET (BG_VOFFSET + 41)
 #define HIGH_SCORE_HOFFSET (BG_HOFFSET + 160)
···
 extern unsigned char exaCol;
 extern bool isHoldingFile;
 extern unsigned char heldFile;
+extern unsigned char gridMoveOffset;
 
-extern clock_t nextLineTime;
+extern clock_t nextMoveTime;
 
 extern unsigned char prevRight, prevLeft, prev2nd, prevAlpha;