Browse Source

added Doxygen configuration file, revised in-place documentation

feature/2015
Christian Kroll 13 years ago
parent
commit
da49b6b3b1
  1. 1772
      Doxyfile
  2. 21
      animations/bitmapscroller.c
  3. 13
      animations/bitmapscroller.h
  4. 169
      animations/fpmath_patterns.c
  5. 13
      animations/fpmath_patterns.h
  6. 35
      animations/mherweg.c
  7. 13
      animations/mherweg.h
  8. 15
      animations/snake.c
  9. 14
      animations/snake.h
  10. 2
      borg_hw/borg_hw.h
  11. 120
      games/snake/snake_game.c
  12. 14
      games/snake/snake_game.h
  13. 30
      games/tetris/bearing.h
  14. 13
      games/tetris/bucket.c
  15. 28
      games/tetris/bucket.h
  16. 15
      games/tetris/highscore.c
  17. 14
      games/tetris/highscore.h
  18. 57
      games/tetris/input.c
  19. 48
      games/tetris/input.h
  20. 14
      games/tetris/piece.c
  21. 41
      games/tetris/piece.h
  22. 14
      games/tetris/tetris_main.c
  23. 14
      games/tetris/tetris_main.h
  24. 19
      games/tetris/variant_bastet.c
  25. 26
      games/tetris/variant_bastet.h
  26. 20
      games/tetris/variant_fp.c
  27. 21
      games/tetris/variant_fp.h
  28. 17
      games/tetris/variant_std.c
  29. 16
      games/tetris/variant_std.h
  30. 21
      games/tetris/variants.h
  31. 27
      games/tetris/view.c
  32. 30
      games/tetris/view.h

1772
Doxyfile

File diff suppressed because it is too large

21
animations/bitmapscroller.c

@ -1,3 +1,14 @@
/**
* \defgroup bitmap Bitmap scroller for the Borg.
* @{
*/
/**
* @file bitmapscroller.c
* @brief Implementation of a bitmap scroller for the Borg.
* @author Christian Kroll
*/
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <assert.h> #include <assert.h>
@ -25,7 +36,7 @@ typedef struct bitmap_t
unsigned char nXDomain; /**< Last valid x-coordinate for viewport. */ unsigned char nXDomain; /**< Last valid x-coordinate for viewport. */
unsigned char nYDomain; /**< Last valid y-coordinate for viewport. */ unsigned char nYDomain; /**< Last valid y-coordinate for viewport. */
unsigned char nChunkDomain; /**< Last valid chunk for viewport. */ unsigned char nChunkDomain; /**< Last valid chunk for viewport. */
unsigned char nChunkCount; /**< Amount of horiz. chunks of the bitmap.*/ unsigned char nChunkCount; /**< Number of horiz. chunks of the bitmap.*/
} }
bitmap_t; bitmap_t;
@ -175,11 +186,11 @@ static void bitmap_recalculateVector(bitmap_t const *const pBitmap,
* This function scrolls through a bitmap. * This function scrolls through a bitmap.
* @param nWidth Width of the bitmap. * @param nWidth Width of the bitmap.
* @param nHeight Height of bitmap. * @param nHeight Height of bitmap.
* @param nBitPlanes Amount of bit planes. * @param nBitPlanes Number of bit planes.
* @param nTickCount How many ticks the animation will last. * @param nTickCount How many ticks the animation will last.
* @param nTick Time quantum in milliseconds. * @param nTick Time quantum in milliseconds.
* @param nFrameTickDivider Amount of ticks between frame changes. * @param nFrameTickDivider Number of ticks between frame changes.
* @param nMovementTickDiver Amount of ticks between movement changes. * @param nMovementTickDiver Number of ticks between movement changes.
* @param fpGetChunk Function that returns an eight-by-one chunk of a bitmap. * @param fpGetChunk Function that returns an eight-by-one chunk of a bitmap.
*/ */
void bitmap_scroll(unsigned char const nWidth, void bitmap_scroll(unsigned char const nWidth,
@ -234,3 +245,5 @@ void bitmap_scroll(unsigned char const nWidth,
wait(nTick); wait(nTick);
} }
} }
/*@}*/

13
animations/bitmapscroller.h

@ -1,3 +1,14 @@
/**
* \addtogroup bitmap
* @{
*/
/**
* @file bitmapscroller.h
* @brief Public interface for the Borg's bitmap scroller.
* @author Christian Kroll
*/
#ifndef BITMAP_SCROLLER_H_ #ifndef BITMAP_SCROLLER_H_
#define BITMAP_SCROLLER_H_ #define BITMAP_SCROLLER_H_
@ -33,3 +44,5 @@ void bitmap_scroll(unsigned char const nWidth,
bitmap_getChunk_t fpGetChunk); bitmap_getChunk_t fpGetChunk);
#endif /* BITMAP_SCROLLER_H_ */ #endif /* BITMAP_SCROLLER_H_ */
/*@}*/

169
animations/fpmath_patterns.c

@ -1,5 +1,12 @@
/** /**
* Routines for drawing patterns generated by fixed point math functions. * \defgroup fixedpoint Fixed-point based animated plasma patterns.
*/
/*@{*/
/**
* @file fpmath_patterns.c
* @brief Routines for drawing patterns generated by fixed-point math functions.
* @author Christian Kroll
*/ */
#include <assert.h> #include <assert.h>
@ -10,10 +17,6 @@
#include "../util.h" #include "../util.h"
#include "fpmath_patterns.h" #include "fpmath_patterns.h"
/**
* \defgroup fixedpoint Fixed-point based animated plasma patterns.
*/
/*@{*/
/** /**
* Double buffering helps in reducing the effect of visibly redrawing every * Double buffering helps in reducing the effect of visibly redrawing every
@ -52,26 +55,26 @@
#ifdef LOW_PRECISION #ifdef LOW_PRECISION
/** This is the type we expect ordinary integers to be. */ /** This is the type we expect ordinary integers to be. */
typedef int16_t ordinary_int_t; typedef int16_t ordinary_int_t;
/** This is the type which we use for fixed point values. */ /** This is the type which we use for fixed-point values. */
typedef int16_t fixp_t; typedef int16_t fixp_t;
/** This type covers arguments of fixSin() and fixCos(). */ /** This type covers arguments of fixSin() and fixCos(). */
typedef int16_t fixp_trig_t; typedef int16_t fixp_trig_t;
/** This type covers interim results of fixed point operations. */ /** This type covers interim results of fixed-point operations. */
typedef uint32_t fixp_interim_t; typedef uint32_t fixp_interim_t;
/** This type covers interim results of the fixed point sqrt() function. */ /** This type covers interim results of the fixSqrt() function. */
typedef uint16_t ufixp_interim_t; typedef uint16_t ufixp_interim_t;
/** Amount of bits the fixed point sqrt() function can handle. */ /** Number of bits the fixSqrt() function can handle. */
#define SQRT_BITS 16 #define SQRT_BITS 16
// NOTE: If you change the following values, don't forget to adapt the sine // NOTE: If you change the following values, don't forget to adapt the sine
// lookup table as well! // lookup table as well!
/** Multiply a number by this factor to convert it to a fixed point value.*/ /** Multiply a number by this factor to convert it to a fixed-point value.*/
#define FIX 32 #define FIX 32
/** Amount of fractional bits of a value (i.e. ceil(log_2(FIX))). */ /** Number of fractional bits of a value (i.e. ceil(log_2(FIX))). */
#define FIX_FRACBITS 5 #define FIX_FRACBITS 5
/** /**
* The amount of temporal quantization steps of the sine lookup table. It * The number of temporal quantization steps of the sine lookup table. It
* must be a divisor of (FIX * 2 * pi) and this divisor must be divisable by * must be a divisor of (FIX * 2 * pi) and this divisor must be divisable by
* 4 itself. Approximate this value as close as possible to keep rounding * 4 itself. Approximate this value as close as possible to keep rounding
* errors at a minimum. * errors at a minimum.
@ -99,26 +102,26 @@
#else #else
/** This is the type we expect ordinary integers to be. */ /** This is the type we expect ordinary integers to be. */
typedef int16_t ordinary_int_t; typedef int16_t ordinary_int_t;
/** This is the type which we use for fixed point values. */ /** This is the type which we use for fixed-point values. */
typedef int16_t fixp_t; typedef int16_t fixp_t;
/** This type covers arguments of fixSin() and fixCos(). */ /** This type covers arguments of fixSin() and fixCos(). */
typedef int32_t fixp_trig_t; typedef int32_t fixp_trig_t;
/** This type covers interim results of fixed point operations. */ /** This type covers interim results of fixed-point operations. */
typedef int32_t fixp_interim_t; typedef int32_t fixp_interim_t;
/** This type covers interim results of the fixed point sqrt() function. */ /** This type covers interim results of the fixSqrt() function. */
typedef uint32_t ufixp_interim_t; typedef uint32_t ufixp_interim_t;
/** Amount of bits the fixed point sqrt() function can handle. */ /** Number of bits the fixSqrt() function can handle. */
#define SQRT_BITS 32 #define SQRT_BITS 32
// NOTE: If you change the following values, don't forget to adapt the sine // NOTE: If you change the following values, don't forget to adapt the sine
// lookup table as well! // lookup table as well!
/** Multiply a number by this factor to convert it to a fixed point value.*/ /** Multiply a number by this factor to convert it to a fixed-point value.*/
#define FIX 256 #define FIX 256
/** Amount of fractional bits of a value (i.e. ceil(log_2(FIX))). */ /** Number of fractional bits of a value (i.e. ceil(log_2(FIX))). */
#define FIX_FRACBITS 8 #define FIX_FRACBITS 8
/** /**
* The amount of temporal quantization steps of the sine lookup table. It * The number of temporal quantization steps of the sine lookup table. It
* must be a divisor of (FIX * 2 * pi) and this divisor must be divisable by * must be a divisor of (FIX * 2 * pi) and this divisor must be divisable by
* 4 itself. Approximate this value as close as possible to keep rounding * 4 itself. Approximate this value as close as possible to keep rounding
* errors at a minimum. * errors at a minimum.
@ -149,18 +152,18 @@
/** The ordinary pi constant. */ /** The ordinary pi constant. */
#define PI 3.14159265358979323846 #define PI 3.14159265358979323846
/** Fixed point version of (pi / 2). */ /** Fixed-point version of (pi / 2). */
#define FIX_PI_2 ((fixp_t)(PI * FIX / 2)) #define FIX_PI_2 ((fixp_t)(PI * FIX / 2))
/** Fixed point version of pi. */ /** Fixed-point version of pi. */
#define FIX_PI ((fixp_t)(PI * FIX)) #define FIX_PI ((fixp_t)(PI * FIX))
/** Fixed point version of (2 * pi). */ /** Fixed-point version of (2 * pi). */
#define FIX_2PI ((fixp_t)(2 * PI * FIX)) #define FIX_2PI ((fixp_t)(2 * PI * FIX))
/** /**
* Scales an ordinary integer up to its fixed point format. * Scales an ordinary integer up to its fixed-point format.
* @param a an ordinary integer to be scaled up * @param a An ordinary integer to be scaled up.
* @return The given value in fixed point format. * @return The given value in fixed-point format.
*/ */
inline static fixp_t fixScaleUp(ordinary_int_t a) inline static fixp_t fixScaleUp(ordinary_int_t a)
{ {
@ -169,10 +172,10 @@ inline static fixp_t fixScaleUp(ordinary_int_t a)
/** /**
* Scales a fixed point value down to an ordinary integer (omitting the * Scales a fixed-point value down to an ordinary integer (omitting the
* fractional part). * fractional part).
* @param a fixed point value to be scaled down * @param a Fixed-point value to be scaled down to an integer.
* @return The given value in fixed point format. * @return The given value as an integer.
*/ */
inline static ordinary_int_t fixScaleDown(fixp_t const a) inline static ordinary_int_t fixScaleDown(fixp_t const a)
{ {
@ -181,9 +184,9 @@ inline static ordinary_int_t fixScaleDown(fixp_t const a)
/** /**
* Multiplies two fixed point values. * Multiplies two fixed-point values.
* @param a operand a * @param a A multiplicand.
* @param b operand b * @param b A multiplying factor.
* @return Product of a and b. * @return Product of a and b.
*/ */
inline static fixp_interim_t fixMul(fixp_t const a, fixp_t const b) inline static fixp_interim_t fixMul(fixp_t const a, fixp_t const b)
@ -193,9 +196,9 @@ inline static fixp_interim_t fixMul(fixp_t const a, fixp_t const b)
/** /**
* Divides two fixed point values. * Divides two fixed-point values.
* @param a operand a * @param a A dividend.
* @param b operand b * @param b A divisor.
* @return Quotient of a and b. * @return Quotient of a and b.
*/ */
inline static fixp_t fixDiv(fixp_interim_t const a, fixp_interim_t const b) inline static fixp_t fixDiv(fixp_interim_t const a, fixp_interim_t const b)
@ -205,13 +208,13 @@ inline static fixp_t fixDiv(fixp_interim_t const a, fixp_interim_t const b)
/** /**
* Fixed point variant of the sine function which receives a fixed point angle * Fixed-point variant of the sine function which receives a fixed-point angle
* (radian). It uses a lookup table which models the first quarter of a full * (radian). It uses a lookup table which models the first quarter of a full
* sine period and calculates the rest from that quarter. * sine period and calculates the rest from that quarter.
* @param angle fixed point radian value * @param fAngle A fixed-point value in radian.
* @return Result of the sine function normalized to a range from -FIX to FIX. * @return Result of the sine function normalized to a range from -FIX to FIX.
*/ */
static fixp_t fixSin(fixp_t fAngle) static fixp_t fixSin(fixp_trig_t fAngle)
{ {
// convert given fixed-point angle to its corresponding quantization step // convert given fixed-point angle to its corresponding quantization step
int8_t nSign = 1; int8_t nSign = 1;
@ -251,22 +254,22 @@ static fixp_t fixSin(fixp_t fAngle)
/** /**
* Fixed point variant of the cosine function which takes a fixed point angle * Fixed-point variant of the cosine function which takes a fixed-point angle
* (radian). It adds FIX_PI_2 to the given angle and consults the fixSin() * (radian). It adds FIX_PI_2 to the given angle and consults the fixSin()
* function for the final result. * function for the final result.
* @param angle fixed point radian value * @param fAngle A fixed-point value in radian.
* @return Result of the cosine function normalized to a range from -FIX to FIX. * @return Result of the cosine function normalized to a range from -FIX to FIX.
*/ */
static fixp_t fixCos(fixp_t const angle) static fixp_t fixCos(fixp_trig_t const fAngle)
{ {
return fixSin(angle + FIX_PI_2); return fixSin(fAngle + FIX_PI_2);
} }
/** /**
* Fixed point square root algorithm as proposed by Ken Turkowski: * Fixed-point square root algorithm as proposed by Ken Turkowski:
* http://www.realitypixels.com/turk/computergraphics/FixedSqrt.pdf * http://www.realitypixels.com/turk/computergraphics/FixedSqrt.pdf
* @param radicant we want the square root of * @param a The radicant we want the square root of.
* @return The square root of the given value. * @return The square root of the given value.
*/ */
static fixp_t fixSqrt(ufixp_interim_t const a) static fixp_t fixSqrt(ufixp_interim_t const a)
@ -295,11 +298,11 @@ static fixp_t fixSqrt(ufixp_interim_t const a)
/** /**
* Calculates the distance between two points. * Calculates the distance between two points.
* @param x1 x coordinate of the first point * @param x1 x-coordinate of the first point
* @param y1 y coordinate of the first point * @param y1 y-coordinate of the first point
* @param x2 x coordinate of the second point * @param x2 x-coordinate of the second point
* @param y2 y coordinate of the second point * @param y2 y-coordinate of the second point
* @return The distance between the given coordinates. * @return The distance between the given points.
*/ */
static fixp_t fixDist(fixp_t const x1, static fixp_t fixDist(fixp_t const x1,
fixp_t const y1, fixp_t const y1,
@ -312,12 +315,12 @@ static fixp_t fixDist(fixp_t const x1,
/** /**
* This pointer type covers functions which return a brightness value for the * This pointer type covers functions which return a brightness value for the
* given coordinates and a "step" value. This actually results in a more or less * given coordinates and a "step" value. Applied to all coordinates of the
* "beautiful" pattern. * borg's display this actually results in a more or less beautiful pattern.
* @param x x-coordinate * @param x x-coordinate
* @param y y-coordinate * @param y y-coordinate
* @param t step value which changes for each frame, allowing for animations * @param t A step value which changes for each frame, allowing for animations.
* @param r pointer to persistent data required by the pattern function * @param r A pointer to persistent data required by the pattern function.
* @return The brightness value (0 < n <= NUM_PLANES) of the given coordinate. * @return The brightness value (0 < n <= NUM_PLANES) of the given coordinate.
*/ */
typedef unsigned char (*fpmath_pattern_func_t)(unsigned char const x, typedef unsigned char (*fpmath_pattern_func_t)(unsigned char const x,
@ -334,12 +337,12 @@ typedef unsigned char (*fpmath_pattern_func_t)(unsigned char const x,
/** /**
* Draws an animated two dimensional graph for a given function f(x, y, t). * Draws an animated two dimensional graph for a given function f(x, y, t).
* @param t_start start value for the function's step variable * @param t_start A start value for the function's step variable.
* @param t_stop stop value for the function's step variable * @param t_stop A stop value for the function's step variable.
* @param t_delta value by which the function's step variable gets incremented * @param t_delta Value by which the function's step variable gets incremented.
* @param frame_delay frame delay in milliseconds * @param frame_delay The frame delay in milliseconds.
* @param fpPattern function which generates a pattern depending on x, y and t * @param fpPattern Function which generates a pattern depending on x, y and t.
* @param r pointer to persistent data required by the fpPattern function * @param r A pointer to persistent data required by the fpPattern function.
*/ */
static void fixPattern(fixp_t const t_start, static void fixPattern(fixp_t const t_start,
fixp_t const t_stop, fixp_t const t_stop,
@ -387,22 +390,42 @@ static void fixPattern(fixp_t const t_start,
/** /**
* This type maintains values relevant for the Plasma animation which need to be * This type maintains values relevant for the Plasma animation which need to be
* persistent over consecutive invocations. * persistent over consecutive invocations.
* @see fixAnimPlasma()
*/ */
typedef struct fixp_plasma_s typedef struct fixp_plasma_s
{ {
fixp_t fFunc1[NUM_COLS]; /**< Result of 1st trig. func. depending on x. */ /**
fixp_t fFunc2CosArg; /**< Arg. of 2st trig. func. depending on the frame. */ * This array holds column dependent results of the first internal pattern
fixp_t fFunc2SinArg; /**< Arg. of 2st trig. func. depending on the frame. */ * function. Those results only need to be calculated for the first row of
* the current frame and are then reused for the remaining rows.
*/
fixp_t fFunc1[NUM_COLS];
/**
* This value is part of the formula for the second internal pattern
* function. It needs to be calculated only once per frame.
*/
fixp_t fFunc2CosArg;
/**
* This value is part of the formula for the second internal pattern
* function. It needs to be calculated only once per frame.
*/
fixp_t fFunc2SinArg;
} fixp_plasma_t; } fixp_plasma_t;
/** /**
* Draws a plasma like pattern (sort of... four shades of grey are pretty * Draws a plasma like pattern (sort of... four shades of grey are pretty
* scarce for a neat plasma animation). * scarce for a neat plasma animation). This is realized by superimposing two
* functions which generate independent patterns for themselves.
*
* The first function draws horizontally moving waves and the second function
* draws zoomed-in radiating curls. Together they create a wobbly, plasma like
* pattern.
*
* @param x x-coordinate * @param x x-coordinate
* @param y y-coordinate * @param y y-coordinate
* @param t step value which changes for each frame, allowing for animations * @param t A Step value which changes for each frame, allowing for animations.
* @param r pointer to persistent interim results * @param r A pointer to persistent interim results.
* @return The brightness value (0 < n <= NUM_PLANES) of the given coordinate. * @return The brightness value (0 < n <= NUM_PLANES) of the given coordinate.
*/ */
static unsigned char fixAnimPlasma(unsigned char const x, static unsigned char fixAnimPlasma(unsigned char const x,
@ -439,7 +462,9 @@ static unsigned char fixAnimPlasma(unsigned char const x,
return nRes; return nRes;
} }
/**
* Starting point for the Plasma animation.
*/
void plasma(void) void plasma(void)
{ {
fixp_plasma_t r; fixp_plasma_t r;
@ -461,9 +486,9 @@ void plasma(void)
*/ */
typedef struct fixp_psychedelic_s typedef struct fixp_psychedelic_s
{ {
fixp_t fCos; /** column factor for the circle calculation */ fixp_t fCos; /**< One of the column factors of the curl. */
fixp_t fSin; /** row factor for the circle calculation */ fixp_t fSin; /**< One of the row factors of the curl. */
fixp_interim_t ft10; /** value involved in rotating the animation's center*/ fixp_interim_t ft10; /**< A value involved in rotating the curl's center. */
} fixp_psychedelic_t; } fixp_psychedelic_t;
@ -471,8 +496,8 @@ typedef struct fixp_psychedelic_s
* Draws flowing circular waves with a rotating center. * Draws flowing circular waves with a rotating center.
* @param x x-coordinate * @param x x-coordinate
* @param y y-coordinate * @param y y-coordinate
* @param t step value which changes for each frame, allowing for animations * @param t A step value which changes for each frame, allowing for animations.
* @param r pointer to persistent interim results * @param r A pointer to persistent interim results.
* @return The brightness value (0 < n <= NUM_PLANES) of the given coordinate. * @return The brightness value (0 < n <= NUM_PLANES) of the given coordinate.
*/ */
static unsigned char fixAnimPsychedelic(unsigned char const x, static unsigned char fixAnimPsychedelic(unsigned char const x,
@ -500,6 +525,10 @@ static unsigned char fixAnimPsychedelic(unsigned char const x,
return nResult; return nResult;
} }
/**
* Starting point for the Psychedelic animation.
*/
void psychedelic(void) void psychedelic(void)
{ {
fixp_psychedelic_t r; fixp_psychedelic_t r;

13
animations/fpmath_patterns.h

@ -1,3 +1,14 @@
/**
* \addtogroup fixedpoint
* @{
*/
/**
* @file fpmath_patterns.h
* @brief Public starting points for the fixed-point math based animations.
* @author Christian Kroll
*/
#ifndef FPMATH_PATTERNS_H_ #ifndef FPMATH_PATTERNS_H_
#define FPMATH_PATTERNS_H_ #define FPMATH_PATTERNS_H_
@ -6,3 +17,5 @@ void plasma(void);
void psychedelic(void); void psychedelic(void);
#endif /* FPMATH_PATTERNS_H_ */ #endif /* FPMATH_PATTERNS_H_ */
/*@}*/

35
animations/mherweg.c

@ -1,3 +1,21 @@
/**
* \defgroup mherweg Martin Herweg's animations.
* @{
*/
/**
* @file mherweg.c
* @brief Simple animations for getting started with developing for the Borg.
* @details The following animations were developed by Martin Herweg (hence the
* name) as a personal aid for getting familiar with developing for the
* Borg.
*
* Although these animations are rarely used among Borg owners, we left
* them in because of their simplicity in hopes that a novice Borg
* developer may find them useful.
* @author Martin Herweg
*/
#include "../compat/pgmspace.h" #include "../compat/pgmspace.h"
#include "../random/prng.h" #include "../random/prng.h"
#include "../config.h" #include "../config.h"
@ -5,24 +23,15 @@
#include "../util.h" #include "../util.h"
/* /** macro for simplifying flash memory access */
* The following animations were developed by Martin Herweg (hence the name)
* as a personal aid for getting familiar with programming the Borg.
*
* Although these animations are rarely used among Borg owners, we left them in
* because of their simplicity in hopes that a novice Borg developer may find
* them useful.
*/
// macro for simplifying flash memory access
#define PGM(x) pgm_read_byte(&(x)) #define PGM(x) pgm_read_byte(&(x))
// use 8 bit operands where feasible
#if NUM_ROWS < 64 && NUM_COLS < 64 #if NUM_ROWS < 64 && NUM_COLS < 64
/** use 8 bit operands where feasible */
typedef signed char operand_t; typedef signed char operand_t;
#else #else
/** use 16 bit operands if either width or height are >= 64 */
typedef int operand_t; typedef int operand_t;
#endif #endif
@ -283,3 +292,5 @@ void mherweg()
rectangle1(); rectangle1();
rectangles(); rectangles();
} }
/*@}*/

13
animations/mherweg.h

@ -1,6 +1,19 @@
/**
* \addtogroup mherweg
* @{
*/
/**
* @file mherweg.h
* @brief Public starting point for Martin Herweg's animations.
* @author Martin Herweg
*/
#ifndef MHERWEG_H_ #ifndef MHERWEG_H_
#define MHERWEG_H_ #define MHERWEG_H_
void mherweg(); void mherweg();
#endif /* MHERWEG_H_ */ #endif /* MHERWEG_H_ */
/*@}*/

15
animations/snake.c

@ -1,3 +1,16 @@
/**
* \addtogroup Snake
*
* @{
*/
/**
* @file snake.c
* @brief Starting point for the snake engine in demo mode.
* @author Peter Fuhrmann, Martin Ongsiek, Daniel Otte, Christian Kroll
*/
#include "../games/snake/snake_game.h" #include "../games/snake/snake_game.h"
/** /**
@ -7,3 +20,5 @@ void snake_animation(void)
{ {
snake_engine(1); snake_engine(1);
} }
/*@}*/

14
animations/snake.h

@ -1,6 +1,20 @@
/**
* \addtogroup Snake
*
* @{
*/
/**
* @file snake.h
* @brief Public starting point for the snake engine in demo mode.
* @author Peter Fuhrmann, Martin Ongsiek, Daniel Otte, Christian Kroll
*/
#ifndef SNAKE_H_ #ifndef SNAKE_H_
#define SNAKE_H_ #define SNAKE_H_
void snake_animation(void); void snake_animation(void);
#endif /* SNAKE_H_ */ #endif /* SNAKE_H_ */
/*@}*/

2
borg_hw/borg_hw.h

@ -1,7 +1,7 @@
#ifndef BORG_HW_H #ifndef BORG_HW_H
#define BORG_HW_H #define BORG_HW_H
// LINEBYTES holds the amount of bytes per line within the framebuffer (pixmap) // LINEBYTES holds the number of bytes per line within the frame buffer (pixmap)
#define LINEBYTES (((NUM_COLS-1)/8)+1) #define LINEBYTES (((NUM_COLS-1)/8)+1)

120
games/snake/snake_game.c

@ -1,3 +1,15 @@
/**
* \defgroup Snake Snake, a casual game including a demo mode.
*
* @{
*/
/**
* @file snake_game.c
* @brief Implementation of the snake game.
* @author Peter Fuhrmann, Martin Ongsiek, Daniel Otte, Christian Kroll
*/
#include <assert.h> #include <assert.h>
#include <stdint.h> #include <stdint.h>
#include "../../config.h" #include "../../config.h"
@ -9,6 +21,7 @@
#include "../../menu/menu.h" #include "../../menu/menu.h"
#include "snake_game.h" #include "snake_game.h"
#if defined MENU_SUPPORT && defined GAME_SNAKE #if defined MENU_SUPPORT && defined GAME_SNAKE
// snake icon (MSB is leftmost pixel) // snake icon (MSB is leftmost pixel)
static const uint8_t icon[8] PROGMEM = static const uint8_t icon[8] PROGMEM =
@ -22,55 +35,62 @@ game_descriptor_t snake_game_descriptor __attribute__((section(".game_descriptor
#endif #endif
// If defined, joystick controls are NOT as "seen" by the snake but absolute, /**
// that is, if pressing up, snake goes up, etc. * If defined, joystick controls are NOT as "seen" by the snake but absolute,
* that is, if pressing up, snake goes up, etc.
*/
#define SNAKE_NEWCONTROL #define SNAKE_NEWCONTROL
// limits #if !defined USNAKE_MAX_LENGTH || defined DOXYGEN
#ifndef USNAKE_MAX_LENGTH /** The maximum length of the snake. */
#define USNAKE_MAX_LENGTH 64u #define USNAKE_MAX_LENGTH 64u
#endif #endif
#ifndef SNAKE_MAX_APPLES #if !defined SNAKE_MAX_APPLES || defined DOXYGEN
/** The maximum number of apples lying on the playing field. */
#define SNAKE_MAX_APPLES 10 #define SNAKE_MAX_APPLES 10
#endif #endif
// delays (in milliseconds) #if !defined SNAKE_CYCLE_DELAY || defined DOXYGEN
#ifndef SNAKE_CYCLE_DELAY /** Delay (in ms) between every state change. */
#define SNAKE_CYCLE_DELAY 100 #define SNAKE_CYCLE_DELAY 100
#endif #endif
#ifndef SNAKE_TERMINATION_DELAY
#if !defined SNAKE_TERMINATION_DELAY || defined DOXYGEN
/** Delay (in ms) between every disappearing pixel of a dying snake. */
#define SNAKE_TERMINATION_DELAY 60 #define SNAKE_TERMINATION_DELAY 60
#endif #endif
// colors /** The color of the surrounding border. */
#define SNAKE_COLOR_BORDER 3 #define SNAKE_COLOR_BORDER 3
/** The color of the snake. */
#define SNAKE_COLOR_PROTAGONIST 3 #define SNAKE_COLOR_PROTAGONIST 3
/** The color of the apples. */
#define SNAKE_COLOR_APPLE 3 #define SNAKE_COLOR_APPLE 3
/** /**
* Directions of the snake. * Directions of the snake.
*/ */
enum snake_dir enum snake_dir_e
{ {
SNAKE_DIR_UP, //!< SNAKE_DIR_UP Snake is heading up. SNAKE_DIR_UP, /**< Snake is heading up. */
SNAKE_DIR_RIGHT,//!< SNAKE_DIR_RIGHT Snake is heading right. SNAKE_DIR_RIGHT,/**< Snake is heading right. */
SNAKE_DIR_DOWN, //!< SNAKE_DIR_DOWN Snake is heading down. SNAKE_DIR_DOWN, /**< Snake is heading down. */
SNAKE_DIR_LEFT, //!< SNAKE_DIR_LEFT Snake is heading left. SNAKE_DIR_LEFT, /**< Snake is heading left. */
SNAKE_DIR_NONE //!< SNAKE_DIR_NONE Helper value for a "resting" joystick. SNAKE_DIR_NONE /**< Helper value for a "resting" joystick. */
}; };
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t snake_dir_t; typedef uint8_t snake_dir_t;
#else #else
typedef enum snake_dir snake_dir_t; typedef enum snake_dir_e snake_dir_t;
#endif #endif
/** /**
* This structure represents the snake character itself. It keeps track of the * This structure represents the snake character itself. It keeps track of the
* snake's segments, its head and tail and the direction it is heading. * snake's segments, its head and tail and the direction it is heading.
*/ */
typedef struct snake_protagonist typedef struct snake_protagonist_s
{ {
pixel aSegments[USNAKE_MAX_LENGTH]; /**< All segments of the snake. */ pixel aSegments[USNAKE_MAX_LENGTH]; /**< All segments of the snake. */
uint8_t nHeadIndex; /**< Index of the head segment. */ uint8_t nHeadIndex; /**< Index of the head segment. */
@ -82,20 +102,22 @@ typedef struct snake_protagonist
/** /**
* This structure keeps track of all apples which are on the playing field. * This structure keeps track of all apples which are on the playing field.
*/ */
typedef struct snake_apples typedef struct snake_apples_s
{ {
pixel aApples[SNAKE_MAX_APPLES]; /**< All apple positions */ pixel aApples[SNAKE_MAX_APPLES]; /**< Positions of all existing apples. */
uint8_t nAppleCount; /**< Counter of currently existing apples*/ uint8_t nAppleCount; /**< Count of currently existing apples. */
} snake_apples_t; } snake_apples_t;
/** /**
* Moves a pixel to the given direction. * This function returns the next position which is calculated from a given
* @param pxNext pixel to be moved * (current) position and a direction.
* @param dir direction * @param pxNext The position we're going to leave.
* @param dir The direction that we are heading.
* @return The next position according the given direction.
*/ */
static pixel snake_applyDirection(pixel pxNext, static pixel snake_nextDirection(pixel const pxNext,
snake_dir_t dir) snake_dir_t const dir)
{ {
assert(dir < 4); assert(dir < 4);
static int8_t const nDelta[] = {0, -1, 0, 1, 0}; static int8_t const nDelta[] = {0, -1, 0, 1, 0};
@ -104,7 +126,7 @@ static pixel snake_applyDirection(pixel pxNext,
/** /**
* This functions draws a border around the playing field. * This function draws a border around the playing field.
*/ */
static void snake_drawBorder(void) static void snake_drawBorder(void)
{ {
@ -132,8 +154,9 @@ static void snake_drawBorder(void)
#ifdef GAME_SNAKE #ifdef GAME_SNAKE
/** /**
* Translates port information into directions. * This function translates hardware port information into joystick directions.
* @return Current direction of the joystick * @return The current direction of the joystick.
* @see snake_dir_e
*/ */
static snake_dir_t snake_queryJoystick(void) static snake_dir_t snake_queryJoystick(void)
{ {
@ -164,8 +187,8 @@ static snake_dir_t snake_queryJoystick(void)
#endif #endif
/** /**
* Initializes the structure which represents the snake itself. * This function initializes the structure which represents the snake itself.
* @param pprotSnake The protagonist structure to be initialized. * @param pprotSnake The pointer the protagonist structure to be initialized.
*/ */
static void snake_initGameProtagonist(snake_protagonist_t *pprotSnake) static void snake_initGameProtagonist(snake_protagonist_t *pprotSnake)
{ {
@ -176,12 +199,11 @@ static void snake_initGameProtagonist(snake_protagonist_t *pprotSnake)
pprotSnake->dir = SNAKE_DIR_UP; pprotSnake->dir = SNAKE_DIR_UP;
} }
#ifdef GAME_SNAKE #ifdef GAME_SNAKE
/** /**
* Determines the next direction of the snake depending on joystick input. * Determines the next direction of the snake depending on the joystick's input.
* @param pprotSnake Protagonist structure to be controlled. * @param pprotSnake A pointer to the structure of the protagonist.
* @param pdirLast The last joystick movement to avoid key repeat. * @param pdirLast Last joystick direction to recognize prolonged key presses.
*/ */
static void snake_userControl(snake_protagonist_t *pprotSnake, static void snake_userControl(snake_protagonist_t *pprotSnake,
snake_dir_t *pdirLast) snake_dir_t *pdirLast)
@ -198,7 +220,8 @@ static void snake_userControl(snake_protagonist_t *pprotSnake,
} }
#else #else
if ((dirJoystick ^ *pdirLast) && (dirJoystick != SNAKE_DIR_NONE)) if ((dirJoystick ^ *pdirLast) && (dirJoystick != SNAKE_DIR_NONE))
{ // only left or right movements are valid {
// only left or right movements are valid
if (dirJoystick & 0x01) if (dirJoystick & 0x01)
{ {
// rotate through directions (either clockwise or counterclockwise) // rotate through directions (either clockwise or counterclockwise)
@ -214,9 +237,10 @@ static void snake_userControl(snake_protagonist_t *pprotSnake,
#ifdef ANIMATION_SNAKE #ifdef ANIMATION_SNAKE
/** /**
* Approaches directions which may lead to an apple. * This function approximates the next direction which may lead to an apple
* @param pprotSnake The hungry protagonist. * (with a particular probability).
* @param pApples A bunch of apples. * @param pprotSnake A pointer to the hungry protagonist.
* @param pApples A pointer to a bunch of apples.
*/ */
static void snake_autoRoute(snake_protagonist_t *pprotSnake, static void snake_autoRoute(snake_protagonist_t *pprotSnake,
snake_apples_t *pApples) snake_apples_t *pApples)
@ -271,7 +295,7 @@ static void snake_autoRoute(snake_protagonist_t *pprotSnake,
for (uint8_t i = 0; i < 4; ++i) for (uint8_t i = 0; i < 4; ++i)
{ {
pixel pxTest = snake_applyDirection(pxHead, pprotSnake->dir); pixel pxTest = snake_nextDirection(pxHead, pprotSnake->dir);
if (get_pixel(pxTest)) if (get_pixel(pxTest))
{ {
for (uint8_t j = 0; j < pApples->nAppleCount; ++j) for (uint8_t j = 0; j < pApples->nAppleCount; ++j)
@ -294,8 +318,8 @@ static void snake_autoRoute(snake_protagonist_t *pprotSnake,
/** /**
* Small animation that lets the dying snake disappear. * Small animation that lets the dying snake disappear piece by piece.
* @param pprotSnake Pointer to the dying snake. * @param pprotSnake A pointer to the dying snake.
*/ */
static void snake_eliminateProtagonist(snake_protagonist_t *pprotSnake) static void snake_eliminateProtagonist(snake_protagonist_t *pprotSnake)
{ {
@ -310,7 +334,7 @@ static void snake_eliminateProtagonist(snake_protagonist_t *pprotSnake)
/** /**
* Initializes the structure that keeps track of all currently existing apples. * Initializes the structure that keeps track of all currently existing apples.
* @param pApples Pointer to the apples in question. * @param pApples Pointer to the set of apples in question.
*/ */
static void snake_initApples(snake_apples_t *pApples) static void snake_initApples(snake_apples_t *pApples)
{ {
@ -320,7 +344,7 @@ static void snake_initApples(snake_apples_t *pApples)
/** /**
* Checks for an apple at a given position and removes it if there is one. * Checks for an apple at a given position and removes it if there is one.
* @param pApples The set of apples which are one the playing field * @param pApples The set of apples which are lying on the playing field.
* @param pxHead The position to be tested. * @param pxHead The position to be tested.
* @return 0 if no apples were found, 1 otherwise * @return 0 if no apples were found, 1 otherwise
*/ */
@ -345,7 +369,7 @@ static uint8_t snake_checkForApple(snake_apples_t *pApples, pixel pxHead)
/** /**
* Creates some new apples from time to time. * Creates some new apples from time to time.
* @param pApples Pointer to the apple structure. * @param pApples Pointer to a set of apples.
*/ */
static void snake_spawnApples(snake_apples_t *pApples) static void snake_spawnApples(snake_apples_t *pApples)
{ {
@ -362,7 +386,9 @@ static void snake_spawnApples(snake_apples_t *pApples)
/** /**
* The snake game. * The main loop (plus initialization) that both drives the game and the
* demo mode.
* @param bDemoMode 0 indicates game mode, 1 indicates demo mode
*/ */
void snake_engine(uint8_t bDemoMode) void snake_engine(uint8_t bDemoMode)
{ {
@ -399,7 +425,7 @@ void snake_engine(uint8_t bDemoMode)
pixel pxOldHead = protSnake.aSegments[protSnake.nHeadIndex]; pixel pxOldHead = protSnake.aSegments[protSnake.nHeadIndex];
protSnake.nHeadIndex = (protSnake.nHeadIndex + 1) % USNAKE_MAX_LENGTH; protSnake.nHeadIndex = (protSnake.nHeadIndex + 1) % USNAKE_MAX_LENGTH;
protSnake.aSegments[protSnake.nHeadIndex] = protSnake.aSegments[protSnake.nHeadIndex] =
snake_applyDirection(pxOldHead, protSnake.dir); snake_nextDirection(pxOldHead, protSnake.dir);
// look if we have found an apple // look if we have found an apple
if (!snake_checkForApple(&apples, if (!snake_checkForApple(&apples,
@ -440,3 +466,5 @@ void snake_game(void)
{ {
snake_engine(0); snake_engine(0);
} }
/*@}*/

14
games/snake/snake_game.h

@ -1,3 +1,15 @@
/**
* \addtogroup Snake
*
* @{
*/
/**
* @file snake_game.h
* @brief Public interface of the snake game engine.
* @author Peter Fuhrmann, Martin Ongsiek, Daniel Otte, Christian Kroll
*/
#ifndef SNAKE_GAME_H_ #ifndef SNAKE_GAME_H_
#define SNAKE_GAME_H_ #define SNAKE_GAME_H_
@ -7,3 +19,5 @@ void snake_engine(uint8_t bDemoMode);
void snake_game(void); void snake_game(void);
#endif /* SNAKE_GAME_H_ */ #endif /* SNAKE_GAME_H_ */
/*@}*/

30
games/tetris/bearing.h

@ -1,19 +1,37 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file bearing.h
* @brief Public interface for denoting the current bearing of the bucket.
* @author Christian Kroll
*/
#ifndef BEARING_H_ #ifndef BEARING_H_
#define BEARING_H_ #define BEARING_H_
#include <stdint.h> #include <stdint.h>
enum tetris_bearing /**
* Denotes the bearing of the bucket.
*/
enum tetris_bearing_e
{ {
TETRIS_BEARING_0, TETRIS_BEARING_0, //!< TETRIS_BEARING_0
TETRIS_BEARING_90, TETRIS_BEARING_90, //!< TETRIS_BEARING_90
TETRIS_BEARING_180, TETRIS_BEARING_180,//!< TETRIS_BEARING_180
TETRIS_BEARING_270 TETRIS_BEARING_270 //!< TETRIS_BEARING_270
}; };
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t tetris_bearing_t; typedef uint8_t tetris_bearing_t;
#else #else
typedef enum tetris_bearing tetris_bearing_t; typedef enum tetris_bearing_e tetris_bearing_t;
#endif #endif
#endif /* BEARING_H_ */ #endif /* BEARING_H_ */
/*@}*/

13
games/tetris/bucket.c

@ -1,3 +1,14 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file bucket.c
* @brief Implementation of Tetris' game logic.
* @author Christian Kroll
*/
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
@ -7,7 +18,6 @@
#include "bucket.h" #include "bucket.h"
#include "piece.h" #include "piece.h"
/*************************** /***************************
* non-interface functions * * non-interface functions *
***************************/ ***************************/
@ -498,3 +508,4 @@ uint16_t* tetris_bucket_predictNextRow(tetris_bucket_iterator_t *pIt)
} }
#endif /* GAME_BASTET */ #endif /* GAME_BASTET */
/*@}*/

28
games/tetris/bucket.h

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file bucket.h
* @brief Public interface definitions of Tetris' game logic module.
* @author Christian Kroll
*/
#ifndef BUCKET_H_ #ifndef BUCKET_H_
#define BUCKET_H_ #define BUCKET_H_
@ -23,7 +35,7 @@
*********/ *********/
// directions to which a piece can be moved // directions to which a piece can be moved
enum tetris_bucket_direction enum tetris_bucket_direction_e
{ {
TETRIS_BUD_LEFT = -1, TETRIS_BUD_LEFT = -1,
TETRIS_BUD_RIGHT = 1 TETRIS_BUD_RIGHT = 1
@ -31,12 +43,12 @@ enum tetris_bucket_direction
#ifdef NDEBUG #ifdef NDEBUG
typedef int8_t tetris_bucket_direction_t; typedef int8_t tetris_bucket_direction_t;
#else #else
typedef enum tetris_bucket_direction tetris_bucket_direction_t; typedef enum tetris_bucket_direction_e tetris_bucket_direction_t;
#endif #endif
// status of the bucket // status of the bucket
enum tetris_bucket_status enum tetris_bucket_status_e
{ {
TETRIS_BUS_HOVERING = 0, /** piece is hovering */ TETRIS_BUS_HOVERING = 0, /** piece is hovering */
TETRIS_BUS_GLIDING = 1, /** piece is gliding on the dump */ TETRIS_BUS_GLIDING = 1, /** piece is gliding on the dump */
@ -47,12 +59,12 @@ enum tetris_bucket_status
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t tetris_bucket_status_t; typedef uint8_t tetris_bucket_status_t;
#else #else
typedef enum tetris_bucket_status tetris_bucket_status_t; typedef enum tetris_bucket_status_e tetris_bucket_status_t;
#endif #endif
// tetris_bucket_t // tetris_bucket_t
typedef struct tetris_bucket typedef struct tetris_bucket_s
{ {
int8_t nWidth; /** width of bucket */ int8_t nWidth; /** width of bucket */
int8_t nHeight; /** height of bucket */ int8_t nHeight; /** height of bucket */
@ -69,7 +81,7 @@ tetris_bucket_t;
// iterator for predicted dump rows // iterator for predicted dump rows
typedef struct tetris_bucket_iterator typedef struct tetris_bucket_iterator_s
{ {
tetris_bucket_t *pBucket; /** bucket to be examined */ tetris_bucket_t *pBucket; /** bucket to be examined */
uint16_t nPieceMap; /** piece bitmap */ uint16_t nPieceMap; /** piece bitmap */
@ -330,7 +342,7 @@ int8_t tetris_bucket_predictDeepestRow(tetris_bucket_t *pBucket,
* @param pPiece the piece which should be tested * @param pPiece the piece which should be tested
* @param nRow the row where the given piece collides * @param nRow the row where the given piece collides
* @param nColumn the column where the piece should be dropped * @param nColumn the column where the piece should be dropped
* @return amount of complete lines * @return number of complete lines
*/ */
int8_t tetris_bucket_predictCompleteLines(tetris_bucket_t *pBucket, int8_t tetris_bucket_predictCompleteLines(tetris_bucket_t *pBucket,
tetris_piece_t *pPiece, tetris_piece_t *pPiece,
@ -364,3 +376,5 @@ uint16_t *tetris_bucket_predictNextRow(tetris_bucket_iterator_t *pIt);
#endif /* GAME_BASTET */ #endif /* GAME_BASTET */
#endif /*BUCKET_H_*/ #endif /*BUCKET_H_*/
/*@}*/

15
games/tetris/highscore.c

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file highscore.c
* @brief Implementation of the high score table input module.
* @author Michael Holzt, Christian Kroll
*/
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <stdint.h> #include <stdint.h>
@ -9,6 +21,7 @@
#include "highscore.h" #include "highscore.h"
/** The global high score table (located in the EEPROM), */
tetris_highscore_table_t g_highScoreTable EEMEM; tetris_highscore_table_t g_highScoreTable EEMEM;
@ -100,3 +113,5 @@ uint16_t tetris_highscore_retrieveHighScore(tetris_highscore_index_t nIndex)
// a score of 65535 is most likely caused by uninitialized EEPROM addresses // a score of 65535 is most likely caused by uninitialized EEPROM addresses
return nHighScore == UINT16_MAX ? 0 : nHighScore; return nHighScore == UINT16_MAX ? 0 : nHighScore;
} }
/*@}*/

14
games/tetris/highscore.h

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file highscore.h
* @brief Public interface definitions of the high score table input module.
* @author Michael Holzt, Christian Kroll
*/
#ifndef TETRIS_HIGHSCORE_H_ #ifndef TETRIS_HIGHSCORE_H_
#define TETRIS_HIGHSCORE_H_ #define TETRIS_HIGHSCORE_H_
@ -100,3 +112,5 @@ void tetris_highscore_saveHighScoreName(tetris_highscore_index_t nIndex,
#endif /*TETRIS_HIGHSCORE_H_*/ #endif /*TETRIS_HIGHSCORE_H_*/
/*@}*/

57
games/tetris/input.c

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file input.c
* @brief Implementation of the input routines of Tetris.
* @author Christian Kroll
*/
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
@ -8,30 +20,27 @@
#include "bearing.h" #include "bearing.h"
#include "input.h" #include "input.h"
#define WAIT(ms) wait(ms)
#define PM(value) pgm_read_byte(&value)
/**
* \defgroup TetrisInputDefinesPrivate Input: Internal constants
*/
/*@{*/
/*********** /***********
* defines * * defines *
***********/ ***********/
/** amount of milliseconds that each loop cycle waits */ #define WAIT(ms) wait(ms)
#define PM(value) pgm_read_byte(&value)
/** Number of milliseconds that each loop cycle waits. */
#define TETRIS_INPUT_TICKS 5 #define TETRIS_INPUT_TICKS 5
/** /**
* amount of milliseconds the input is ignored after the pause combo has been * Number of milliseconds the input is ignored after the pause key combination
* pressed, since it is difficult to release all buttons simultaneously * has been pressed, since it is difficult to release all buttons
* simultaneously.
*/ */
#define TETRIS_INPUT_PAUSE_TICKS 100 #define TETRIS_INPUT_PAUSE_TICKS 100
/** /**
* amount of allowed loop cycles while in pause mode so that the game * Number of allowed loop cycles while in pause mode so that the game
* automatically continues after five minutes * automatically continues after five minutes.
*/ */
#define TETRIS_INPUT_PAUSE_CYCLES 60000 #define TETRIS_INPUT_PAUSE_CYCLES 60000
@ -40,29 +49,23 @@
/** delay (in loop cycles) for key repeat */ /** delay (in loop cycles) for key repeat */
#define TETRIS_INPUT_REPEAT_DELAY 5 #define TETRIS_INPUT_REPEAT_DELAY 5
/** amount of loop cyles the left button is ignored */ /** Number of loop cyles the left button is ignored */
#define TETRIS_INPUT_CHATTER_TICKS_LEFT 12 #define TETRIS_INPUT_CHATTER_TICKS_LEFT 12
/** amount of loop cyles the right button is ignored */ /** Number of loop cyles the right button is ignored */
#define TETRIS_INPUT_CHATTER_TICKS_RIGHT 12 #define TETRIS_INPUT_CHATTER_TICKS_RIGHT 12
/** amount of loop cyles the down button is ignored */ /** Number of loop cyles the down button is ignored */
#define TETRIS_INPUT_CHATTER_TICKS_DOWN 12 #define TETRIS_INPUT_CHATTER_TICKS_DOWN 12
/** amount of loop cyles the clockwise rotation button is ignored */ /** Number of loop cyles the clockwise rotation button is ignored */
#define TETRIS_INPUT_CHATTER_TICKS_ROT_CW 24 #define TETRIS_INPUT_CHATTER_TICKS_ROT_CW 24
/** amount of loop cyles the counter clockwise rotation button is ignored */ /** Number of loop cyles the counter clockwise rotation button is ignored */
#define TETRIS_INPUT_CHATTER_TICKS_ROT_CCW 24 #define TETRIS_INPUT_CHATTER_TICKS_ROT_CCW 24
/** amount of loop cyles the drop button is ignored */ /** Number of loop cyles the drop button is ignored */
#define TETRIS_INPUT_CHATTER_TICKS_DROP 36 #define TETRIS_INPUT_CHATTER_TICKS_DROP 36
/** wait cycles per level (array of uint8_t) */ /** wait cycles per level (array of uint8_t) */
#define TETRIS_INPUT_LVL_CYCLES 200, 133, 100, 80, 66, 57, 50, 44, 40, 36, 33, \ #define TETRIS_INPUT_LVL_CYCLES 200, 133, 100, 80, 66, 57, 50, 44, 40, 36, 33, \
30, 28, 26, 25, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9 30, 28, 26, 25, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9
/*@}*/
/**
* \defgroup TetrisInputNoInterface Input: Internal non-interface functions
*/
/*@{*/
/*************************** /***************************
* non-interface functions * * non-interface functions *
@ -79,7 +82,7 @@ static void tetris_input_chatterProtect(tetris_input_t *pIn,
// never exceed the index // never exceed the index
assert(cmd < TETRIS_INCMD_NONE); assert(cmd < TETRIS_INCMD_NONE);
// amount of loop cycles a command is ignored after its button has been // number of loop cycles a command is ignored after its button has been
// released (every command has its own counter) // released (every command has its own counter)
static uint8_t const nInitialIgnoreValue[TETRIS_INCMD_NONE] PROGMEM = static uint8_t const nInitialIgnoreValue[TETRIS_INCMD_NONE] PROGMEM =
{ {
@ -214,8 +217,6 @@ static tetris_input_command_t tetris_input_queryJoystick(tetris_input_t *pIn)
return cmdReturn; return cmdReturn;
} }
/*@}*/
/**************************** /****************************
* construction/destruction * * construction/destruction *
@ -384,3 +385,5 @@ void tetris_input_setBearing(tetris_input_t *pIn,
// changes its meaning as soon as the bearing changes // changes its meaning as soon as the bearing changes
pIn->cmdLast = tetris_input_mapCommand(pIn->nBearing, pIn->cmdRawLast); pIn->cmdLast = tetris_input_mapCommand(pIn->nBearing, pIn->cmdRawLast);
} }
/*@}*/

48
games/tetris/input.h

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
*@{
*/
/**
* @file input.h
* @brief Public interface definitions of the input module of Tetris.
* @author Christian Kroll
*/
#ifndef INPUT_H_ #ifndef INPUT_H_
#define INPUT_H_ #define INPUT_H_
@ -6,10 +18,6 @@
#include <assert.h> #include <assert.h>
#include "bearing.h" #include "bearing.h"
/**
* \defgroup TetrisInputDefinesPublic Input: Public constants
*/
/*@{*/
/*********** /***********
* defines * * defines *
@ -18,13 +26,6 @@
/** number of levels */ /** number of levels */
#define TETRIS_INPUT_LEVELS 30 #define TETRIS_INPUT_LEVELS 30
/*@}*/
/**
* \defgroup TetrisInputTypes Input: Data types
*/
/*@{*/
/********* /*********
* types * * types *
@ -33,7 +34,7 @@
/** /**
* allowed input values * allowed input values
*/ */
enum tetris_input_command enum tetris_input_command_e
{ {
TETRIS_INCMD_RIGHT, /**< move piece right */ TETRIS_INCMD_RIGHT, /**< move piece right */
TETRIS_INCMD_DOWN, /**< lower piece by one row */ TETRIS_INCMD_DOWN, /**< lower piece by one row */
@ -48,14 +49,14 @@ enum tetris_input_command
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t tetris_input_command_t; typedef uint8_t tetris_input_command_t;
#else #else
typedef enum tetris_input_command tetris_input_command_t; typedef enum tetris_input_command_e tetris_input_command_t;
#endif #endif
/** /**
* values which influence the gravity time limit for a piece * values which influence the gravity time limit for a piece
*/ */
enum tetris_input_pace enum tetris_input_pace_e
{ {
TETRIS_INPACE_HOVERING = 0, /**< normal falling pace */ TETRIS_INPACE_HOVERING = 0, /**< normal falling pace */
TETRIS_INPACE_GLIDING = 75 /**< guarantees a minimum docking time to avoid TETRIS_INPACE_GLIDING = 75 /**< guarantees a minimum docking time to avoid
@ -64,17 +65,17 @@ enum tetris_input_pace
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t tetris_input_pace_t; typedef uint8_t tetris_input_pace_t;
#else #else
typedef enum tetris_input_pace tetris_input_pace_t; typedef enum tetris_input_pace_e tetris_input_pace_t;
#endif #endif
/** /**
* data structure for the input module * data structure for the input module
*/ */
typedef struct tetris_input typedef struct tetris_input_s
{ {
/** /**
* Amount of loop cycles between forced piece movements. This value gets * Number of loop cycles between forced piece movements. This value gets
* set via the tetris_input_setLevel() function. * set via the tetris_input_setLevel() function.
*/ */
uint8_t nMaxCycles; uint8_t nMaxCycles;
@ -88,7 +89,7 @@ typedef struct tetris_input
uint8_t nLoopCycles; uint8_t nLoopCycles;
/** /**
* Amount of loop cycles in which the same command has been issued * Number of loop cycles in which the same command has been issued
* consecutively. It gets reset if either the current command differs from * consecutively. It gets reset if either the current command differs from
* the last one or a well-defined value has been reached (thereby * the last one or a well-defined value has been reached (thereby
* regulating the pace of the key repeat as commands are only processed * regulating the pace of the key repeat as commands are only processed
@ -131,13 +132,6 @@ typedef struct tetris_input
} }
tetris_input_t; tetris_input_t;
/*@}*/
/**
* \defgroup TetrisInputRelated Input: Interface functions
*/
/*@{*/
/**************************** /****************************
* construction/destruction * * construction/destruction *
@ -200,6 +194,6 @@ void tetris_input_resetDownKeyRepeat(tetris_input_t *pIn);
void tetris_input_setBearing(tetris_input_t *pIn, void tetris_input_setBearing(tetris_input_t *pIn,
tetris_bearing_t nBearing); tetris_bearing_t nBearing);
/*@}*/
#endif /*INPUT_H_*/ #endif /*INPUT_H_*/
/*@}*/

14
games/tetris/piece.c

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
*@{
*/
/**
* @file piece.c
* @brief Implementation of the piece module.
* @author Christian Kroll
*/
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <stdint.h> #include <stdint.h>
@ -55,3 +67,5 @@ uint8_t tetris_piece_getAngleCount(tetris_piece_t *pPc)
return pgm_read_byte(&angleCounts[pPc->shape]); return pgm_read_byte(&angleCounts[pPc->shape]);
} }
/*@}*/

41
games/tetris/piece.h

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file piece.h
* @brief Public interface definitions of the piece module.
* @author Christian Kroll
*/
#ifndef TETRIS_PIECE_H_ #ifndef TETRIS_PIECE_H_
#define TETRIS_PIECE_H_ #define TETRIS_PIECE_H_
@ -5,17 +17,13 @@
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
/**
* \defgroup TetrisPieceTypes Piece: Data types
*/
/*@{*/
/********* /*********
* types * * types *
*********/ *********/
/** shape attributes for a piece */ /** shape attributes for a piece */
enum tetris_piece_shape enum tetris_piece_shape_e
{ {
TETRIS_PC_LINE, /**< the I shaped brick */ TETRIS_PC_LINE, /**< the I shaped brick */
TETRIS_PC_T, /**< the T shaped brick */ TETRIS_PC_T, /**< the T shaped brick */
@ -28,12 +36,12 @@ enum tetris_piece_shape
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t tetris_piece_shape_t; typedef uint8_t tetris_piece_shape_t;
#else #else
typedef enum tetris_piece_shape tetris_piece_shape_t; typedef enum tetris_piece_shape_e tetris_piece_shape_t;
#endif #endif
/** possible angles for a brick */ /** possible angles for a brick */
enum tetris_piece_angle enum tetris_piece_angle_e
{ {
TETRIS_PC_ANGLE_0, /**< standard angle */ TETRIS_PC_ANGLE_0, /**< standard angle */
TETRIS_PC_ANGLE_90, /**< rotated by 90 degrees */ TETRIS_PC_ANGLE_90, /**< rotated by 90 degrees */
@ -43,11 +51,11 @@ enum tetris_piece_angle
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t tetris_piece_angle_t; typedef uint8_t tetris_piece_angle_t;
#else #else
typedef enum tetris_piece_angle tetris_piece_angle_t; typedef enum tetris_piece_angle_e tetris_piece_angle_t;
#endif #endif
/** rotation attributes */ /** rotation attributes */
enum tetris_piece_rotation enum tetris_piece_rotation_e
{ {
TETRIS_PC_ROT_CW = 1, /**< clockwise rotation */ TETRIS_PC_ROT_CW = 1, /**< clockwise rotation */
TETRIS_PC_ROT_CCW = 3 /**< counter clockwise rotation */ TETRIS_PC_ROT_CCW = 3 /**< counter clockwise rotation */
@ -55,7 +63,7 @@ enum tetris_piece_rotation
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t tetris_piece_rotation_t; typedef uint8_t tetris_piece_rotation_t;
#else #else
typedef enum tetris_piece_rotation tetris_piece_rotation_t; typedef enum tetris_piece_rotation_e tetris_piece_rotation_t;
#endif #endif
/** /**
@ -63,20 +71,13 @@ enum tetris_piece_rotation
* @see tetris_piece_shape_t * @see tetris_piece_shape_t
* @see tetris_piece_angle_t * @see tetris_piece_angle_t
*/ */
typedef struct tetris_piece typedef struct tetris_piece_s
{ {
tetris_piece_shape_t shape; /**< specifies the shape of the piece */ tetris_piece_shape_t shape; /**< specifies the shape of the piece */
tetris_piece_angle_t angle; /**< specifies one of 4 angels */ tetris_piece_angle_t angle; /**< specifies one of 4 angels */
} }
tetris_piece_t; tetris_piece_t;
/*@}*/
/**
* \defgroup TetrisPieceRelated Piece: Interface functions
*/
/*@{*/
/***************************** /*****************************
* construction/destruction * * construction/destruction *
@ -215,6 +216,6 @@ inline static int8_t tetris_piece_getBottomOffset(uint16_t const nBitmap)
return 0; // last three rows of the piece are empty return 0; // last three rows of the piece are empty
} }
/*@}*/
#endif /*TETRIS_PIECE_H_*/ #endif /*TETRIS_PIECE_H_*/
/*@}*/

14
games/tetris/tetris_main.c

@ -1,3 +1,14 @@
/**
* \defgroup tetris Tetris, the popular puzzle game.
* @{
*/
/**
* @file tetris_main.c
* @brief Main loop of the Tetris module.
* @author Christian Kroll
*/
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <stdint.h> #include <stdint.h>
@ -10,7 +21,6 @@
#include "view.h" #include "view.h"
#include "tetris_main.h" #include "tetris_main.h"
void tetris_main(tetris_variant_t const *const pVariantMethods) void tetris_main(tetris_variant_t const *const pVariantMethods)
{ {
// get view dependent dimensions of the bucket // get view dependent dimensions of the bucket
@ -206,3 +216,5 @@ void tetris_main(tetris_variant_t const *const pVariantMethods)
tetris_bucket_destruct(pBucket); tetris_bucket_destruct(pBucket);
tetris_piece_destruct(pPiece); tetris_piece_destruct(pPiece);
} }
/*@}*/

14
games/tetris/tetris_main.h

@ -1,3 +1,14 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file tetris_main.h
* @brief Public prototype of Tetris' main loop function.
* @author Christian Kroll
*/
#ifndef TETRIS_MAIN_H_ #ifndef TETRIS_MAIN_H_
#define TETRIS_MAIN_H_ #define TETRIS_MAIN_H_
@ -10,5 +21,6 @@
*/ */
void tetris_main(tetris_variant_t const *const pVariantMethods); void tetris_main(tetris_variant_t const *const pVariantMethods);
#endif /* TETRIS_MAIN_H_ */ #endif /* TETRIS_MAIN_H_ */
/*@}*/

19
games/tetris/variant_bastet.c

@ -1,3 +1,20 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file variant_bastet.c
* @brief Implementation of the "Bastard Tetris" module.
* @details Based on the game "Bastet" (version 0.41) by Frederico Poloni. His
* code isn't used as the Borg's Tetris framework is too different from
* that of "Petris" (on which Bastet is based), but the algorithms of
* this implementation are closely modeled after his ideas.
* @author Christian Kroll
* @see Frederico Poloni's homepage: http://fph.altervista.org/prog/bastet.html
*/
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
@ -514,3 +531,5 @@ tetris_bearing_t tetris_bastet_getBearing(void *pVariantData)
{ {
return TETRIS_BEARING_0; return TETRIS_BEARING_0;
} }
/*@}*/

26
games/tetris/variant_bastet.h

@ -1,3 +1,20 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file variant_bastet.h
* @brief Public interface of the "Bastard Tetris" module.
* @details Based on the game "Bastet" (version 0.41) by Frederico Poloni. His
* code isn't used as the Borg's Tetris framework is too different from
* that of "Petris" (on which Bastet is based), but the algorithms of
* this implementation are closely modeled after his ideas.
* @author Christian Kroll
* @see Frederico Poloni's homepage: http://fph.altervista.org/prog/bastet.html
*/
#ifndef VARIANT_BASTET_H_ #ifndef VARIANT_BASTET_H_
#define VARIANT_BASTET_H_ #define VARIANT_BASTET_H_
@ -9,6 +26,7 @@
#include "input.h" #include "input.h"
#include "variants.h" #include "variants.h"
/*************** /***************
* entry point * * entry point *
***************/ ***************/
@ -23,7 +41,7 @@ void tetris_bastet(void);
* types * * types *
*********/ *********/
typedef struct tetris_bastet_scorepair typedef struct tetris_bastet_scorepair_s
{ {
tetris_piece_shape_t shape; tetris_piece_shape_t shape;
int16_t nScore; int16_t nScore;
@ -31,10 +49,10 @@ typedef struct tetris_bastet_scorepair
tetris_bastet_scorepair_t; tetris_bastet_scorepair_t;
typedef struct tetris_bastet_variant typedef struct tetris_bastet_variant_s
{ {
uint16_t nScore; /** score of the player */ uint16_t nScore; /** score of the player */
uint16_t nHighscore; /** highscore */ uint16_t nHighscore; /** high score */
uint16_t nHighscoreName; /** champion's initials */ uint16_t nHighscoreName; /** champion's initials */
uint8_t nLevel; /** current level */ uint8_t nLevel; /** current level */
uint16_t nLines; /** number of completed lines */ uint16_t nLines; /** number of completed lines */
@ -210,3 +228,5 @@ void tetris_bastet_setLastInput(void *pVariantData,
tetris_bearing_t tetris_bastet_getBearing(void *pVariantData); tetris_bearing_t tetris_bastet_getBearing(void *pVariantData);
#endif /*VARIANT_BASTET_H_*/ #endif /*VARIANT_BASTET_H_*/
/*@}*/

20
games/tetris/variant_fp.c

@ -1,3 +1,21 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file variant_fp.c
* @brief Implementation of the "First Person Tetris" module.
* @details Originally implemented by Michael Holzt. However, his implementation
* did not quite fit into this framework anymore as it was heavily
* modified to improve modularization. Therefore, his code got replaced
* completely. Sorry about that, but thanks for the original
* implementation nonetheless!
* @author Christian Kroll
* @see variant_std.c
*/
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <stdint.h> #include <stdint.h>
@ -102,3 +120,5 @@ void tetris_fp_setLastInput(void *pVariantData,
} }
pStdVariant->nBearing %= 4; pStdVariant->nBearing %= 4;
} }
/*@}*/

21
games/tetris/variant_fp.h

@ -1,3 +1,20 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file variant_fp.h
* @brief Public interface of the "First Person Tetris" module.
* @details Originally implemented by Michael Holzt. However, his implementation
* did not quite fit into this framework anymore as it was heavily
* modified to improve modularization. Therefore, his code got replaced
* completely. Sorry about that, but thanks for the original
* implementation nonetheless!
* @author Christian Kroll
* @see variant_std.h
*/
#ifndef VARIANT_FP_H_ #ifndef VARIANT_FP_H_
#define VARIANT_FP_H_ #define VARIANT_FP_H_
@ -26,7 +43,7 @@ tetris_variant_t const tetrisFpVariant;
/** /**
* retrieves the variant's highscore index * retrieves the variant's high score index
* @param pVariantData the variant data object we want information from * @param pVariantData the variant data object we want information from
*/ */
tetris_highscore_index_t tetris_fp_getHighscoreIndex(void *pVariantData); tetris_highscore_index_t tetris_fp_getHighscoreIndex(void *pVariantData);
@ -43,3 +60,5 @@ void tetris_fp_setLastInput(void *pVariantData,
uint8_t bMoveOk); uint8_t bMoveOk);
#endif /*VARIANT_FP_H_*/ #endif /*VARIANT_FP_H_*/
/*@}*/

17
games/tetris/variant_std.c

@ -1,3 +1,18 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file variant_std.c
* @brief Implementation of the standard Tetris module.
* @details The routines of this file provide selection of new pieces, line
* counting, score calculation, high score management, adjustment of
* the bucket's bearing and so on.
* @author Christian Kroll
*/
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
@ -255,3 +270,5 @@ tetris_bearing_t tetris_std_getBearing(void *pVariantData)
return pStdVariant->nBearing; return pStdVariant->nBearing;
} }
/*@}*/

16
games/tetris/variant_std.h

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file variant_std.h
* @brief Public interface of the standard Tetris module.
* @author Christian Kroll
*/
#ifndef VARIANT_STD_H_ #ifndef VARIANT_STD_H_
#define VARIANT_STD_H_ #define VARIANT_STD_H_
@ -25,7 +37,7 @@ void tetris(void);
* types * * types *
*********/ *********/
typedef struct tetris_standard_variant_t typedef struct tetris_standard_variant_s
{ {
uint16_t nScore; /** score of the player */ uint16_t nScore; /** score of the player */
uint16_t nHighscore; /** highscore */ uint16_t nHighscore; /** highscore */
@ -193,3 +205,5 @@ void tetris_std_setLastInput(void *pVariantData,
tetris_bearing_t tetris_std_getBearing(void *pVariantData); tetris_bearing_t tetris_std_getBearing(void *pVariantData);
#endif /*VARIANT_STD_H_*/ #endif /*VARIANT_STD_H_*/
/*@}*/

21
games/tetris/variants.h

@ -1,3 +1,19 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file variants.h
* @brief Public interface of a Tetris variant.
* @details This header file describes a struct containing function pointers
* that every Tetris variant has to implement. It resembles an abstract
* C++ class whose virtual methods need to be implemented.
* @author Christian Kroll
* @see Have a look at variant_std.c which not only implements a fairly standard
* Tetris variant but also serves as an example for new variants to come!
*/
#ifndef VARIANTS_H_ #ifndef VARIANTS_H_
#define VARIANTS_H_ #define VARIANTS_H_
@ -8,7 +24,8 @@
#include "bucket.h" #include "bucket.h"
#include "input.h" #include "input.h"
typedef struct tetris_variant
typedef struct tetris_variant_s
{ {
/** /**
* constructs a variant data object * constructs a variant data object
@ -148,4 +165,6 @@ typedef struct tetris_variant
} }
tetris_variant_t; tetris_variant_t;
/*@}*/
#endif /*VARIANTS_H_*/ #endif /*VARIANTS_H_*/

27
games/tetris/view.c

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file view.c
* @brief Implementation of Tetris' graphical output routines.
* @author Christian Kroll
*/
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
@ -13,11 +25,6 @@
#include "view.h" #include "view.h"
/**
* \defgroup TetrisViewDefinesPrivate View: Internal constants
*/
/*@{*/
/*********** /***********
* defines * * defines *
***********/ ***********/
@ -103,13 +110,6 @@
#endif #endif
/*@}*/
/**
* \defgroup TetrisViewNoInterface View: Internal non-interface functions
*/
/*@{*/
/*************************** /***************************
* non-interface functions * * non-interface functions *
@ -568,7 +568,6 @@ static void tetris_view_formatHighscoreName(uint16_t nHighscoreName,
} }
pszName[3] = '\0'; pszName[3] = '\0';
} }
/*@}*/
/**************************** /****************************
@ -674,3 +673,5 @@ void tetris_view_showResults(tetris_view_t *pV)
scrolltext(pszResults); scrolltext(pszResults);
#endif #endif
} }
/*@}*/

30
games/tetris/view.h

@ -1,3 +1,15 @@
/**
* \addtogroup tetris
* @{
*/
/**
* @file view.c
* @brief Public interface definitions of Tetris' graphical output routines.
* @author Christian Kroll
*/
#ifndef TETRIS_VIEW_H_ #ifndef TETRIS_VIEW_H_
#define TETRIS_VIEW_H_ #define TETRIS_VIEW_H_
@ -7,17 +19,12 @@
#include "variants.h" #include "variants.h"
/**
* \defgroup TetrisViewTypes View: Data types
*/
/*@{*/
/********* /*********
* types * * types *
*********/ *********/
/** presentation modes */ /** presentation modes */
enum tetris_view_mode enum tetris_view_mode_e
{ {
TETRIS_VIMO_PAUSED, TETRIS_VIMO_PAUSED,
TETRIS_VIMO_RUNNING TETRIS_VIMO_RUNNING
@ -25,12 +32,12 @@ enum tetris_view_mode
#ifdef NDEBUG #ifdef NDEBUG
typedef uint8_t tetris_view_mode_t; typedef uint8_t tetris_view_mode_t;
#else #else
typedef enum tetris_view_mode tetris_view_mode_t; typedef enum tetris_view_mode_e tetris_view_mode_t;
#endif #endif
/** data structure that drives the view module */ /** data structure that drives the view module */
typedef struct tetris_view typedef struct tetris_view_s
{ {
tetris_variant_t const *pVariantMethods; /** variant function pointers */ tetris_variant_t const *pVariantMethods; /** variant function pointers */
void *pVariant; /** associated variant object */ void *pVariant; /** associated variant object */
@ -42,13 +49,6 @@ typedef struct tetris_view
} }
tetris_view_t; tetris_view_t;
/*@}*/
/**
* \defgroup TetrisInterface View: Interface functions
*/
/*@{*/
/***************************** /*****************************
* construction/destruction * * construction/destruction *

Loading…
Cancel
Save