resolved some signedness issues, still many to go (btw: 78 bytes eliminated in the process)

animations/bitmapscroller.c

@@ -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))
-	{
-		*pdx = random8() % 2u * (x < (pBitmap->nXDomain / 2) ? 1 : -1);
-	}
-	if (((y + *pdy) > (pBitmap->nYDomain)) || ((y + *pdy) < 0))
+	signed char nResult;
+	if (((nComponent == 0u) || (nComponent >= nDomain)) && nDelta)
 	{
-		*pdy = random8() % 2u * (y < (pBitmap->nYDomain / 2) ? 1 : -1);
+		nResult = (signed char)(random8() & 0x01) * (nComponent ? -1 : 1);
 	}
-	if (*pdx == 0 && *pdy == 0)
+	else
 	{
-		*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;
 		}

animations/bitmapscroller.h

@@ -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);

animations/blackhole.c

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

animations/fpmath_patterns.c

@@ -288,7 +288,7 @@ static fixp_t fixSqrt(ufixp_interim_t const a)
 			nRoot++;
 		}
 	} while (nCount-- != 0);
-	return (nRoot);
+	return (fixp_t)nRoot;
 }
 
 

animations/gameoflife.c

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

animations/ltn_ant.c

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

animations/program.c

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

animations/program.h

@@ -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();

animations/squares.c

@@ -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);

can/borg_can.c

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

games/breakout/ball.c

@@ -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);
 }

games/breakout/playfield.c

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

games/breakout/playfield.h

@@ -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 */

games/snake/snake_game.c

@@ -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);

games/space_invaders/invaders2.c

@@ -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);

games/space_invaders/invaders2.h

@@ -132,7 +132,7 @@ typedef struct
 
 typedef struct
 {
-	signed char lives;
+	unsigned char lives;
 	unsigned int points;
 } Player;
 

games/tetris/bucket.c

@@ -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));
 }
 
 

games/tetris/highscore.c

@@ -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

games/tetris/input.c

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

games/tetris/variant_bastet.c

@@ -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));

games/tetris/variant_std.c

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

games/tetris/view.c

@@ -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);
 					}
 				}

pixel.h

@@ -60,7 +60,7 @@ inline static unsigned char get_next_pixel(pixel p, direction_t dir){
 
 
 inline static direction_t direction_r(direction_t dir){
-	return (dir + 1) % 4u;
+	return (dir + 1u) % 4u;
 }