mirror of
https://github.com/thepigeongenerator/tetris_clone.git
synced 2025-12-17 05:55:46 +01:00
119 lines
3.4 KiB
C
119 lines
3.4 KiB
C
#include "placing.h"
|
|
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <sys/cdefs.h>
|
|
|
|
#include "../../io/audio.h"
|
|
#include "../../io/input.h"
|
|
#include "../../util/types.h"
|
|
#include "../../util/vec.h"
|
|
#include "../game.h"
|
|
#include "shapes.h"
|
|
|
|
|
|
/* count the empty columns in the row */
|
|
__attribute_const__ static int count_empty(u8 const* restrict row) {
|
|
int cnt = 0;
|
|
#if defined(__clang__)
|
|
#pragma unroll COLUMNS
|
|
#elif defined(__GNUC__)
|
|
#pragma GCC unroll COLUMNS
|
|
#endif
|
|
for (int i = 0; i < COLUMNS; i++)
|
|
cnt += !row[i];
|
|
return cnt;
|
|
}
|
|
|
|
/* checks for filled rows, clearing a max of 4 consecutive rows, if present.
|
|
* all row pointers will be moved down to fill the gap, the filled rows will be inserted at the top, and zeroed-out */
|
|
static void clear_rows(u8* restrict* restrict rows, u16* const score) {
|
|
u8* cache[4] = {0}; // the I piece is 4 long, meaning only 4 rows can be cleared at a time
|
|
uint fillc = 0;
|
|
uint checkc = 0;
|
|
|
|
for (uint y = 0; y < (ROWS - fillc) && checkc <= 4; y++) {
|
|
int i = (ROWS - 1) - y; // invert the index direction, so we start at the highest index
|
|
rows[i] = rows[i - fillc]; // either assigns the current row to itself, or to the "next" row
|
|
|
|
if (count_empty(rows[i])) {
|
|
checkc += (fillc > 0 && checkc < 4);
|
|
continue;
|
|
}
|
|
|
|
|
|
cache[fillc] = rows[i]; // cache the current row address, since it's going to be overridden
|
|
fillc++;
|
|
checkc++;
|
|
y--;
|
|
}
|
|
|
|
*score += (8 << fillc) * !!fillc;
|
|
for (uint i = 0; i < fillc; i++) {
|
|
memset(cache[i], 0, COLUMNS);
|
|
rows[i] = cache[i];
|
|
}
|
|
}
|
|
|
|
/* writes a shape to the screen */
|
|
static void plcmnt_place(u8* restrict const* restrict row, u8 id, i8vec2 pos) {
|
|
u8 colour = colour_from_id(id);
|
|
|
|
i8vec2 bpos[4];
|
|
shape_getblocks(id, bpos);
|
|
bpos[0] += pos;
|
|
bpos[1] += pos;
|
|
bpos[2] += pos;
|
|
bpos[3] += pos;
|
|
|
|
row[bpos[0][VY]][bpos[0][VX]] = colour;
|
|
row[bpos[1][VY]][bpos[1][VX]] = colour;
|
|
row[bpos[2][VY]][bpos[2][VX]] = colour;
|
|
row[bpos[3][VY]][bpos[3][VX]] = colour;
|
|
}
|
|
|
|
static int plcmnt_valid(u8* restrict const* restrict const rows, i8vec2 pos) {
|
|
return pos[VX] >= 0 && pos[VX] < COLUMNS &&
|
|
pos[VY] >= 0 && pos[VY] < ROWS &&
|
|
!rows[pos[VY]][pos[VX]];
|
|
}
|
|
|
|
static int plcmnt_intersect(u8* restrict const* restrict const rows, u8 const id, i8vec2 pos) {
|
|
i8vec2 bpos[4];
|
|
shape_getblocks(id, bpos);
|
|
return !(plcmnt_valid(rows, pos + bpos[0]) &&
|
|
plcmnt_valid(rows, pos + bpos[1]) &&
|
|
plcmnt_valid(rows, pos + bpos[2]) &&
|
|
plcmnt_valid(rows, pos + bpos[3]));
|
|
}
|
|
|
|
int place_update(struct gamedata* gdat, int movdat) {
|
|
// store the current index and ID, only changes when placed (which yields no movement) and rotation (which occurs last)
|
|
int tmp;
|
|
u8 id = gdat->pdat.cur;
|
|
|
|
// update Y axis
|
|
tmp = !!(movdat & MOVD);
|
|
gdat->pdat.sel[VY] += tmp;
|
|
tmp = tmp && plcmnt_intersect(gdat->rows, id, gdat->pdat.sel);
|
|
if (tmp) {
|
|
gdat->pdat.sel[VY]--;
|
|
plcmnt_place(gdat->rows, id, gdat->pdat.sel);
|
|
clear_rows(gdat->rows, &gdat->pnts); // clear the rows that have been completed
|
|
next_shape();
|
|
audio_play(AUDIO_ID_PLACE);
|
|
|
|
if (plcmnt_intersect(gdat->rows, gdat->pdat.cur, gdat->pdat.sel))
|
|
return 1;
|
|
}
|
|
|
|
// update X axis
|
|
tmp = !!(movdat & MOVR) - !!(movdat & MOVL);
|
|
gdat->pdat.sel[VX] += (tmp && !plcmnt_intersect(gdat->rows, id, (i8vec2){gdat->pdat.sel[VX] + tmp, gdat->pdat.sel[VY]})) * tmp;
|
|
|
|
// update roll
|
|
tmp = id ^ (((!!(movdat & MOVRR) - !!(movdat & MOVRL)) * 8 + id) & 31);
|
|
gdat->pdat.cur ^= (tmp && !plcmnt_intersect(gdat->rows, id ^ tmp, gdat->pdat.sel)) * tmp;
|
|
return 0;
|
|
}
|