ctdo
/
borgware-2d
16
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

added Doxygen configuration file, revised in-place documentation

This commit is contained in:
Christian Kroll 2012-05-07 06:56:00 +00:00
parent f2027360a0
commit da49b6b3b1
32 changed files with 2430 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1772
Doxyfile Normal file
View File

File diff suppressed because it is too large Load Diff

21
animations/bitmapscroller.c
View File

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

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

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

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

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

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

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

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

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

122
games/snake/snake_game.c
View File

@ -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,15 +199,14 @@ 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)
{ {
snake_dir_t dirJoystick = snake_queryJoystick(); snake_dir_t dirJoystick = snake_queryJoystick();
#ifdef SNAKE_NEWCONTROL #ifdef SNAKE_NEWCONTROL
@ -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
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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