resolved some signedness issues, still many to go (btw: 78 bytes eliminated in the process)
This commit is contained in:
parent
92c4613cdb
commit
d3c94d3101
|
@ -152,33 +152,27 @@ static void bitmap_drawViewport(bitmap_t const *const pBitmap,
|
|||
|
||||
|
||||
/**
|
||||
* This functions calculates randomly chosen offsets to move the viewport
|
||||
* accross the bitmap.
|
||||
* @param pBitmap The bitmap of interest.
|
||||
* @param x The current x-coordinate of the viewport.
|
||||
* @param y The current y-coordinate of the viewport.
|
||||
* @param pdx Pointer to a variable which shall hold the horizontal offset.
|
||||
* @param pdy Pointer to a variable which shall hold the vertical offset.
|
||||
* Dices a new value for one component of the movement vector so that the
|
||||
* moving view port changes its direction.
|
||||
* @param nComponent The component (either x or y) we want to change.
|
||||
* @param nDomain The maximum allowed value for nCompoment.
|
||||
* @param nDelta The delta which is currently applied to nComponent.
|
||||
* @return The newly calculated delta for nComponent.
|
||||
*/
|
||||
static void bitmap_recalculateVector(bitmap_t const *const pBitmap,
|
||||
unsigned char const x,
|
||||
unsigned char const y,
|
||||
signed char *const pdx,
|
||||
signed char *const pdy)
|
||||
static signed char bitmap_bounce(unsigned char const nComponent,
|
||||
unsigned char const nDomain,
|
||||
signed char const nDelta)
|
||||
{
|
||||
if (((x + *pdx) > (pBitmap->nXDomain)) || ((x + *pdx) < 0))
|
||||
signed char nResult;
|
||||
if (((nComponent == 0u) || (nComponent >= nDomain)) && nDelta)
|
||||
{
|
||||
*pdx = random8() % 2u * (x < (pBitmap->nXDomain / 2) ? 1 : -1);
|
||||
nResult = (signed char)(random8() & 0x01) * (nComponent ? -1 : 1);
|
||||
}
|
||||
if (((y + *pdy) > (pBitmap->nYDomain)) || ((y + *pdy) < 0))
|
||||
else
|
||||
{
|
||||
*pdy = random8() % 2u * (y < (pBitmap->nYDomain / 2) ? 1 : -1);
|
||||
}
|
||||
if (*pdx == 0 && *pdy == 0)
|
||||
{
|
||||
*pdx = (x < (pBitmap->nXDomain / 2) ? 1 : -1);
|
||||
*pdy = (y < (pBitmap->nYDomain / 2) ? 1 : -1);
|
||||
nResult = nDelta;
|
||||
}
|
||||
return nResult;
|
||||
}
|
||||
|
||||
|
||||
|
@ -197,7 +191,7 @@ void bitmap_scroll(unsigned char const nWidth,
|
|||
unsigned char const nHeight,
|
||||
unsigned char const nBitPlanes,
|
||||
unsigned int const nTickCount,
|
||||
unsigned int const nTick,
|
||||
int const nTick,
|
||||
unsigned char const nFrameTickDivider,
|
||||
unsigned char const nMovementTickDivider,
|
||||
bitmap_getChunk_t fpGetChunk)
|
||||
|
@ -238,7 +232,14 @@ void bitmap_scroll(unsigned char const nWidth,
|
|||
}
|
||||
if ((i % nMovementTickDivider) == 0)
|
||||
{
|
||||
bitmap_recalculateVector(&bitmap, x, y, &dx, &dy);
|
||||
dx = bitmap_bounce(x, bitmap.nXDomain, dx);
|
||||
dy = bitmap_bounce(y, bitmap.nYDomain, dy);
|
||||
if ((dx == 0) && (dy == 0))
|
||||
{
|
||||
dx = (x < (bitmap.nXDomain / 2) ? 1 : -1);
|
||||
dy = (y < (bitmap.nYDomain / 2) ? 1 : -1);
|
||||
}
|
||||
|
||||
x += bitmap.nWidth > bitmap.nViewportWidth ? dx : 0;
|
||||
y += bitmap.nHeight > bitmap.nViewportHeight ? dy : 0;
|
||||
}
|
||||
|
|
|
@ -38,7 +38,7 @@ void bitmap_scroll(unsigned char const nWidth,
|
|||
unsigned char const nHeight,
|
||||
unsigned char const nBitPlanes,
|
||||
unsigned int const nTickCount,
|
||||
unsigned int const nTick,
|
||||
int const nTick,
|
||||
unsigned char const nFrameTickDivider,
|
||||
unsigned char const nMovementTickDivider,
|
||||
bitmap_getChunk_t fpGetChunk);
|
||||
|
|
|
@ -18,7 +18,7 @@
|
|||
* @param angle angle based on an integer (range from 0 to 63)
|
||||
* @return result of the sine function normalized to a range from -64 to 64
|
||||
*/
|
||||
static signed char sin_i(signed char angle) {
|
||||
static signed char sin_i(unsigned char angle) {
|
||||
// the aforementioned lookup table
|
||||
static signed char const sine_table[] PROGMEM =
|
||||
{0, 6, 12, 19, 24, 30, 36, 41, 45, 49, 53, 56, 59, 61, 63, 64};
|
||||
|
|
|
@ -288,7 +288,7 @@ static fixp_t fixSqrt(ufixp_interim_t const a)
|
|||
nRoot++;
|
||||
}
|
||||
} while (nCount-- != 0);
|
||||
return (nRoot);
|
||||
return (fixp_t)nRoot;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -124,14 +124,27 @@ static cell_t getcell(field_t pf, coord_t x, coord_t y) {
|
|||
/******************************************************************************/
|
||||
|
||||
uint8_t countsurroundingalive(field_t pf, coord_t x, coord_t y) {
|
||||
#define P 1u
|
||||
#define NX (XSIZE - 1u) /* emulated horizontal -1 */
|
||||
#define NY (YSIZE - 1u) /* emulated vertical -1 */
|
||||
|
||||
#if XSIZE == YSIZE
|
||||
static coord_t const offset[] = {NX, NX, 0, P, P, P, 0, NX, NX, NX};
|
||||
#else
|
||||
static coord_t const xoffset[] = {0, P, P, P, 0, NX, NX, NX};
|
||||
static coord_t const yoffset[] = {NY, NY, 0, P, P, P, 0, NY};
|
||||
#endif
|
||||
|
||||
static int8_t const offset[] = {-1, -1, 0, +1, +1, +1, 0, -1, -1, -1};
|
||||
x += XSIZE;
|
||||
y += YSIZE;
|
||||
uint8_t i, ret = 0;
|
||||
for (i = 8; i--;) {
|
||||
// getcell(...) returns either 0 or 1
|
||||
ret += getcell(pf, (x + offset[i+2]) % XSIZE, (y + offset[i]) % YSIZE);
|
||||
#if XSIZE == YSIZE
|
||||
ret += getcell(pf, (coord_t)(x + offset[i+2u]) % XSIZE,
|
||||
(coord_t)(y + offset[i]) % YSIZE);
|
||||
#else
|
||||
ret += getcell(pf, (coord_t)(x + xoffset[i]) % XSIZE,
|
||||
(coord_t)(y + yoffset[i]) % YSIZE);
|
||||
#endif
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
@ -315,6 +328,6 @@ void gameoflife() {
|
|||
}
|
||||
}
|
||||
pfcopy(ldbuf[ldbuf_idx], pf1);
|
||||
ldbuf_idx = (ldbuf_idx + 1) % LOOP_DETECT_BUFFER_SIZE;
|
||||
ldbuf_idx = (ldbuf_idx + 1u) % LOOP_DETECT_BUFFER_SIZE;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -19,33 +19,53 @@
|
|||
* IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
|
||||
#include <limits.h>
|
||||
#include "../config.h"
|
||||
#include "../pixel.h"
|
||||
#include "../util.h"
|
||||
#include "../random/prng.h"
|
||||
|
||||
#if (UNUMCOLS <= (UCHAR_MAX / 2)) && (UNUMROWS <= (UCHAR_MAX / 2))
|
||||
typedef unsigned char coord_t;
|
||||
#else
|
||||
typedef unsigned int coord_t;
|
||||
#endif
|
||||
|
||||
#define P (1u)
|
||||
#define NX (UNUM_COLS - 1u)
|
||||
#define NY (UNUM_ROWS - 1u)
|
||||
|
||||
#if UNUM_ROWS == UNUM_COLS
|
||||
static coord_t const dcomp[] = {0, P, NX};
|
||||
#define xdcomp dcomp
|
||||
#define ydcomp dcomp
|
||||
#else
|
||||
static coord_t const xdcomp[] = {0, P, NX};
|
||||
static coord_t const ydcomp[] = {0, P, NY};
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
void ltn_ant() {
|
||||
clear_screen(0);
|
||||
|
||||
struct {
|
||||
unsigned char x, y;
|
||||
unsigned char ox, oy; /* Used to set old pixels so brightness 2 */
|
||||
signed char dx, dy; /* Vector can only be (0,1),(1,0),(0,-1),(-1,0) */
|
||||
coord_t x, y;
|
||||
coord_t ox, oy; /* Used to set old pixels to brightness 2 */
|
||||
coord_t dx, dy; /* Vector can only be (0,1),(1,0),(0,-1),(-1,0) */
|
||||
} ant;
|
||||
|
||||
signed char temp;
|
||||
unsigned char temp;
|
||||
unsigned int cycles = 500;
|
||||
|
||||
/* Random start position and direction */
|
||||
ant.x = random8() % NUM_COLS;
|
||||
ant.y = random8() % NUM_ROWS;
|
||||
ant.x = random8() % UNUM_COLS;
|
||||
ant.y = random8() % UNUM_ROWS;
|
||||
|
||||
/* Make sure we do have a valid vector */
|
||||
ant.dx = (random8() % 3) - 1;
|
||||
ant.dx = xdcomp[random8() % 3];
|
||||
do {
|
||||
ant.dy = (random8() % 3) - 1;
|
||||
ant.dy = ydcomp[random8() % 3];
|
||||
} while(ant.dx == ant.dy);
|
||||
|
||||
ant.ox = ant.x;
|
||||
|
@ -78,15 +98,8 @@ void ltn_ant() {
|
|||
wait(100);
|
||||
|
||||
/* Playing field is modeled after a torus */
|
||||
if(ant.x == 0 && ant.dx < 0)
|
||||
ant.x = NUM_COLS - 1;
|
||||
else
|
||||
ant.x = (ant.x + ant.dx) % UNUM_COLS;
|
||||
|
||||
if(ant.y == 0 && ant.dy < 0)
|
||||
ant.y = NUM_ROWS - 1;
|
||||
else
|
||||
ant.y = (ant.y + ant.dy) % UNUM_ROWS;
|
||||
ant.x = (coord_t)(ant.x + ant.dx) % UNUM_COLS;
|
||||
ant.y = (coord_t)(ant.y + ant.dy) % UNUM_ROWS;
|
||||
|
||||
cycles--;
|
||||
}
|
||||
|
|
|
@ -47,7 +47,7 @@ void test_palette2(){
|
|||
|
||||
|
||||
#ifdef ANIMATION_SPIRAL
|
||||
static void walk(cursor_t* cur, unsigned char steps, unsigned int delay){
|
||||
static void walk(cursor_t* cur, unsigned char steps, int delay){
|
||||
unsigned char x;
|
||||
for(x=steps;x--;){
|
||||
set_cursor(cur, next_pixel(cur->pos, cur->dir));
|
||||
|
@ -55,7 +55,7 @@ static void walk(cursor_t* cur, unsigned char steps, unsigned int delay){
|
|||
}
|
||||
}
|
||||
|
||||
void spiral(unsigned int delay){
|
||||
void spiral(int delay){
|
||||
clear_screen(0);
|
||||
|
||||
cursor_t cur;
|
||||
|
|
|
@ -20,7 +20,7 @@ inline static void off()
|
|||
}
|
||||
#endif
|
||||
|
||||
void spiral(unsigned int delay);
|
||||
void spiral(int delay);
|
||||
void joern1();
|
||||
void checkerboard(unsigned char times);
|
||||
void fire();
|
||||
|
|
|
@ -19,7 +19,7 @@
|
|||
#include "../random/prng.h"
|
||||
#include "squares.h"
|
||||
|
||||
#define STEP_WIDTH (NUMPLANE * 2u)
|
||||
#define STEP ((uint8_t)(NUMPLANE * 2u))
|
||||
#define TICK 100
|
||||
#define CYCLES 200u
|
||||
|
||||
|
@ -44,8 +44,8 @@ void squares(void) {
|
|||
for (uint8_t y = 0; y < NUM_ROWS; ++y) {
|
||||
uint8_t nColor = 0;
|
||||
for (uint8_t nLayer = 0; nLayer < NUMPLANE; ++nLayer) {
|
||||
nColor += (((x + nOffsets[nLayer]) / STEP_WIDTH) + ((y +
|
||||
nOffsets[nLayer] + STEP_WIDTH) / STEP_WIDTH)) % 2u;
|
||||
nColor += (uint8_t)(((x + nOffsets[nLayer]) / STEP) +
|
||||
((y + nOffsets[nLayer] + STEP) / STEP)) % 2u;
|
||||
}
|
||||
setpixel((pixel){x, y},
|
||||
nColorMap[(nColOffset + nColor) % (2* NUMPLANE)]);
|
||||
|
@ -54,7 +54,7 @@ void squares(void) {
|
|||
|
||||
// add randomly calculated offsets to each layer starting points
|
||||
for (uint8_t i = 0; i < NUMPLANE; ++i) {
|
||||
nOffsets[i] = (nOffsets[i] + random8()) % STEP_WIDTH;
|
||||
nOffsets[i] = (uint8_t)(nOffsets[i] + random8()) % STEP;
|
||||
}
|
||||
// rotate color map
|
||||
nColOffset = (nColOffset + 1) % (NUMPLANE * 2);
|
||||
|
|
|
@ -90,7 +90,7 @@ void process_borg_msg(pdo_message *msg)
|
|||
|
||||
case FKT_BORG_SCROLLTEXT_RESET:
|
||||
for (i = 0; i < msg->dlc - 1; i++) {
|
||||
scrolltext_text[i] = msg->data[i];
|
||||
scrolltext_text[i] = (char)msg->data[i];
|
||||
}
|
||||
scrolltext_text[i] = 0;
|
||||
break;
|
||||
|
@ -101,7 +101,7 @@ void process_borg_msg(pdo_message *msg)
|
|||
j++;
|
||||
|
||||
for (i = 0; i < msg->dlc - 1; i++) {
|
||||
scrolltext_text[i + j] = msg->data[i];
|
||||
scrolltext_text[i + j] = (char)msg->data[i];
|
||||
}
|
||||
scrolltext_text[i + j] = 0;
|
||||
break;
|
||||
|
|
|
@ -20,7 +20,7 @@
|
|||
|
||||
/* internal functions */
|
||||
|
||||
static void ball_spawn (ball_t *in_ball, uint16_t in_x, uint16_t in_y, int16_t in_dir_x, int16_t in_dir_y)
|
||||
static void ball_spawn (ball_t *in_ball, int16_t in_x, int16_t in_y, int16_t in_dir_x, int16_t in_dir_y)
|
||||
{
|
||||
in_ball->x = in_x;
|
||||
in_ball->y = in_y;
|
||||
|
@ -41,7 +41,7 @@ static void ball_die (ball_t *in_b)
|
|||
}
|
||||
|
||||
/* modify a vecotor according to given type of bouncing */
|
||||
static void bounce_rand_vector (ball_t *in_b, uint8_t in_bouncetype)
|
||||
static void bounce_rand_vector (ball_t *in_b, int8_t in_bouncetype)
|
||||
{
|
||||
uint8_t rval = random8();
|
||||
|
||||
|
@ -183,6 +183,5 @@ void ball_spawn_default (ball_t *in_b)
|
|||
if (random8() & 0x01)
|
||||
xdir *= -1;
|
||||
|
||||
ball_spawn (in_b, (uint16_t) rebound_getpos() * 256, (NUM_ROWS -2) * 256,
|
||||
xdir, -131);
|
||||
ball_spawn (in_b, rebound_getpos() * 256, (NUM_ROWS - 2) * 256, xdir, -131);
|
||||
}
|
||||
|
|
|
@ -54,7 +54,7 @@ static void draw_single_field (uint8_t in_x, uint8_t in_y, game_field_t in_f)
|
|||
setpixel (tmp, b);
|
||||
}
|
||||
|
||||
static void brick_damage (uint8_t in_x, uint8_t in_y)
|
||||
static void brick_damage (int8_t in_x, int8_t in_y)
|
||||
{
|
||||
if ((*playfield)[in_x][in_y] >= bs || (*playfield)[in_x][in_y] == 0)
|
||||
return;
|
||||
|
@ -74,9 +74,9 @@ void playfield_set (uint8_t in_x, uint8_t in_y, game_field_t in_field)
|
|||
(*playfield)[in_x][in_y] = in_field;
|
||||
}
|
||||
|
||||
uint8_t check_bounce (int8_t in_x, int8_t in_y)
|
||||
int8_t check_bounce (int8_t in_x, int8_t in_y)
|
||||
{
|
||||
uint8_t ov = 0;
|
||||
int8_t ov = 0;
|
||||
/* overflow check */
|
||||
if (in_x >= NUM_ROWS || in_x < 0)
|
||||
ov |= BOUNCE_X;
|
||||
|
|
|
@ -55,6 +55,6 @@ void playfield_set (uint8_t in_x, uint8_t in_y, game_field_t in_field);
|
|||
|
||||
/* @description Checks if there is an object in the way. If so, it returns 1
|
||||
*/
|
||||
uint8_t check_bounce (int8_t in_x, int8_t in_y);
|
||||
int8_t check_bounce (int8_t in_x, int8_t in_y);
|
||||
|
||||
#endif /* PLAYFIELD_H */
|
||||
|
|
|
@ -306,7 +306,7 @@ static void snake_autoRoute(snake_protagonist_t *pprotSnake,
|
|||
return;
|
||||
}
|
||||
}
|
||||
pprotSnake->dir = (pprotSnake->dir + 1) % 4u;
|
||||
pprotSnake->dir = (pprotSnake->dir + 1u) % 4u;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -423,7 +423,7 @@ void snake_engine(uint8_t bDemoMode)
|
|||
|
||||
// actually move head
|
||||
pixel pxOldHead = protSnake.aSegments[protSnake.nHeadIndex];
|
||||
protSnake.nHeadIndex = (protSnake.nHeadIndex + 1) % USNAKE_MAX_LENGTH;
|
||||
protSnake.nHeadIndex = (protSnake.nHeadIndex + 1u) % USNAKE_MAX_LENGTH;
|
||||
protSnake.aSegments[protSnake.nHeadIndex] =
|
||||
snake_nextDirection(pxOldHead, protSnake.dir);
|
||||
|
||||
|
@ -440,7 +440,8 @@ void snake_engine(uint8_t bDemoMode)
|
|||
|
||||
// remove last segment
|
||||
clearpixel(protSnake.aSegments[protSnake.nTailIndex])
|
||||
protSnake.nTailIndex = (protSnake.nTailIndex +1) % USNAKE_MAX_LENGTH;
|
||||
protSnake.nTailIndex =
|
||||
(protSnake.nTailIndex + 1u) % USNAKE_MAX_LENGTH;
|
||||
|
||||
// new apples
|
||||
snake_spawnApples(&apples);
|
||||
|
|
|
@ -103,7 +103,8 @@ void borg_invaders()
|
|||
}
|
||||
else if (ivStatus == 1) //WON
|
||||
{
|
||||
unsigned int bonus= POINTS_FOR_LEVEL * (level + 1) * (12 - iv.pos.y);
|
||||
unsigned int bonus = POINTS_FOR_LEVEL * (level + 1u) *
|
||||
(unsigned int)(12 - iv.pos.y);
|
||||
pl.points += bonus;
|
||||
//printf("cleared l: %d , y: %d bonus: %d \n",
|
||||
// level, iv.pos.y, bonus);
|
||||
|
|
|
@ -132,7 +132,7 @@ typedef struct
|
|||
|
||||
typedef struct
|
||||
{
|
||||
signed char lives;
|
||||
unsigned char lives;
|
||||
unsigned int points;
|
||||
} Player;
|
||||
|
||||
|
|
|
@ -73,7 +73,7 @@ static uint8_t tetris_bucket_collision(tetris_bucket_t *pBucket,
|
|||
int8_t const nStart = nRow + tetris_piece_getBottomOffset(nPieceMap);
|
||||
int8_t const nStop = nRow >= 0 ? nRow : 0;
|
||||
// mask those blocks which are not covered by the piece
|
||||
uint16_t const nDumpMask = nCol >= 0 ? 0x000F << nCol : 0x000F >> -nCol;
|
||||
uint16_t const nDumpMask = nCol >= 0 ? 0x000Fu << nCol : 0x000Fu >> -nCol;
|
||||
// value for shifting blocks to the corresponding part of the piece
|
||||
int8_t nShift = 12 - nCol - 4 * (nRow + 3 - nStart);
|
||||
// compare piece with dump
|
||||
|
@ -124,7 +124,7 @@ tetris_bucket_t *tetris_bucket_construct(int8_t nWidth,
|
|||
tetris_bucket_t *pBucket =
|
||||
(tetris_bucket_t *)malloc(sizeof(tetris_bucket_t));
|
||||
assert(pBucket != NULL);
|
||||
pBucket->dump = (uint16_t *)calloc(nHeight, sizeof(uint16_t));
|
||||
pBucket->dump = (uint16_t *)calloc((size_t)nHeight, sizeof(uint16_t));
|
||||
assert(pBucket->dump != NULL);
|
||||
|
||||
// setting requested attributes
|
||||
|
@ -156,7 +156,7 @@ void tetris_bucket_reset(tetris_bucket_t *pBucket)
|
|||
pBucket->status = TETRIS_BUS_READY;
|
||||
|
||||
// clear dump
|
||||
memset(pBucket->dump, 0, pBucket->nHeight * sizeof(uint16_t));
|
||||
memset(pBucket->dump, 0, (size_t)pBucket->nHeight * sizeof(uint16_t));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -35,7 +35,7 @@ uint16_t tetris_highscore_inputName(void)
|
|||
while (1)
|
||||
{
|
||||
// we need our own blink interval
|
||||
nBlink = (nBlink + 1) % 4u;
|
||||
nBlink = (nBlink + 1u) % 4u;
|
||||
|
||||
// construct command for scrolltext and execute
|
||||
static uint8_t const nOffset[3] = {15, 19, 23};
|
||||
|
@ -98,7 +98,9 @@ uint16_t tetris_highscore_inputName(void)
|
|||
}
|
||||
|
||||
// return result
|
||||
return (pszNick[0] - 65) << 10 | (pszNick[1] - 65) << 5 | (pszNick[2] - 65);
|
||||
return (uint16_t)(pszNick[0] - 65) << 10 |
|
||||
(uint16_t)(pszNick[1] - 65) << 5 |
|
||||
(uint16_t)(pszNick[2] - 65);
|
||||
#else
|
||||
return (0);
|
||||
#endif
|
||||
|
|
|
@ -142,7 +142,7 @@ static
|
|||
tetris_input_command_t tetris_input_mapCommand(tetris_bearing_t nBearing,
|
||||
tetris_input_command_t nCmd)
|
||||
{
|
||||
return (nCmd < TETRIS_INCMD_ROT_CCW) ? (nCmd - nBearing + 4) % 4u : nCmd;
|
||||
return (nCmd < TETRIS_INCMD_ROT_CCW) ? (nCmd - nBearing + 4u) % 4u : nCmd;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -58,12 +58,13 @@
|
|||
static void tetris_bastet_doPreprocessing(tetris_bastet_variant_t *pBastet)
|
||||
{
|
||||
// retrieve sane start and stop values for the column and row indices
|
||||
int8_t const nWidth = tetris_bucket_getWidth(pBastet->pBucket);
|
||||
size_t const nWidth = (size_t)tetris_bucket_getWidth(pBastet->pBucket);
|
||||
int8_t const nStartRow = tetris_bucket_getHeight(pBastet->pBucket) - 1;
|
||||
int8_t const nStopRow = tetris_bucket_getFirstTaintedRow(pBastet->pBucket);
|
||||
|
||||
// clear old precalculated scores (last three elements are always 0)
|
||||
memset(pBastet->pColScore, 0, nWidth * sizeof(int16_t));
|
||||
|
||||
// calculate the column heights of the actual bucket configuration
|
||||
// NOTE: in this loop, pColScore stores the actual column heights,
|
||||
// later it will contain the "score impact" of every unchanged column
|
||||
|
@ -132,7 +133,7 @@ static void tetris_bastet_predictColHeights(tetris_bastet_variant_t *pBastet,
|
|||
pBastet->pBucket, pPiece, nDeepestRow, nColumn);
|
||||
while (pDump != NULL)
|
||||
{
|
||||
uint16_t nColMask = 0x0001 << nStartCol;
|
||||
uint16_t nColMask = 0x0001u << nStartCol;
|
||||
for (int8_t x = nStartCol; x <= nStopCol; ++x)
|
||||
{
|
||||
if ((*pDump & nColMask) != 0)
|
||||
|
@ -248,9 +249,9 @@ static void tetris_bastet_evaluatePieces(tetris_bastet_variant_t *pBastet)
|
|||
TETRIS_PC_ANGLE_0);
|
||||
for (uint8_t nBlock = TETRIS_PC_LINE; nBlock <= TETRIS_PC_Z; ++nBlock)
|
||||
{
|
||||
int16_t nMaxScore = -32768;
|
||||
int16_t nMaxScore = INT16_MIN;
|
||||
tetris_piece_setShape(pPiece, nBlock);
|
||||
int8_t nAngleCount = tetris_piece_getAngleCount(pPiece);
|
||||
uint8_t nAngleCount = tetris_piece_getAngleCount(pPiece);
|
||||
for (uint8_t nAngle = TETRIS_PC_ANGLE_0; nAngle < nAngleCount; ++nAngle)
|
||||
{
|
||||
tetris_piece_setAngle(pPiece, nAngle);
|
||||
|
@ -325,7 +326,7 @@ void *tetris_bastet_construct(tetris_bucket_t *pBucket)
|
|||
|
||||
pBastet->pBucket = pBucket;
|
||||
|
||||
int8_t nWidth = tetris_bucket_getWidth(pBastet->pBucket);
|
||||
size_t nWidth = (size_t)tetris_bucket_getWidth(pBastet->pBucket);
|
||||
pBastet->pColScore = (int16_t*) calloc(nWidth + 3, sizeof(int16_t));
|
||||
pBastet->pStartingRow = (int8_t*) calloc(nWidth + 3, sizeof(int8_t));
|
||||
pBastet->pColHeights = (int8_t*) calloc(nWidth, sizeof(int8_t));
|
||||
|
|
|
@ -150,7 +150,7 @@ void tetris_std_completeDrop(void *pVariantData,
|
|||
assert(pVariantData != 0);
|
||||
tetris_standard_variant_t *pStdVariant =
|
||||
(tetris_standard_variant_t *)pVariantData;
|
||||
pStdVariant->nScore += nLines * 2;
|
||||
pStdVariant->nScore += nLines * 2u;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -243,8 +243,8 @@ static void tetris_view_drawDump(tetris_view_t *pV)
|
|||
tetris_piece_getBitmap(tetris_bucket_getPiece(pV->pBucket));
|
||||
// clear all bits of the piece we are not interested in and
|
||||
// align the remaining row to LSB
|
||||
int8_t y = nRow - nPieceRow;
|
||||
nPieceMap = (nPieceMap & (0x000F << (y * 4))) >> (y * 4);
|
||||
uint8_t y = (uint8_t)(nRow - nPieceRow);
|
||||
nPieceMap = (nPieceMap & (0x000Fu << (y * 4u))) >> (y * 4u);
|
||||
// shift remaining part to current column and embed piece into view
|
||||
nRowMap |= nColumn >= 0 ?
|
||||
nPieceMap << nColumn : nPieceMap >> -nColumn;
|
||||
|
@ -256,7 +256,7 @@ static void tetris_view_drawDump(tetris_view_t *pV)
|
|||
unsigned char nColor = (nRowMap & nElementMask) ?
|
||||
tetris_view_getPieceColor(pV) : TETRIS_VIEW_COLORSPACE;
|
||||
tetris_view_setpixel(nBearing, TETRIS_VIEW_XOFFSET_DUMP + x,
|
||||
TETRIS_VIEW_YOFFSET_DUMP + nRow, nColor);
|
||||
TETRIS_VIEW_YOFFSET_DUMP + (uint8_t)nRow, nColor);
|
||||
nElementMask <<= 1;
|
||||
}
|
||||
}
|
||||
|
@ -481,8 +481,8 @@ static void tetris_view_blinkLines(tetris_view_t *pV)
|
|||
uint8_t nColor = (nColIdx == 0 ? TETRIS_VIEW_COLORFADE
|
||||
: TETRIS_VIEW_COLORPIECE);
|
||||
tetris_view_setpixel(nBearing,
|
||||
TETRIS_VIEW_XOFFSET_DUMP + x,
|
||||
TETRIS_VIEW_YOFFSET_DUMP + y,
|
||||
TETRIS_VIEW_XOFFSET_DUMP + (uint8_t)x,
|
||||
TETRIS_VIEW_YOFFSET_DUMP + (uint8_t)y,
|
||||
nColor);
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue