rockbox/apps/recorder/wormlet.c

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2002 Philipp Pertermann
 *
 * All files in this archive are subject to the GNU General Public License.
 * See the file COPYING in the source tree root for full license agreement.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/

#include "config.h"
#include "options.h"

#ifdef USE_GAMES

/* #define DEBUG_WORMLET */

#include <sprintf.h>
#include <stdlib.h>
#include <string.h>
#include "system.h"
#include "lcd.h"
#include "button.h"
#include "kernel.h"
#include "menu.h"
#include "rtc.h"
#include "lang.h"
#include "screens.h"
#include "font.h"

/* size of the field the worm lives in */
#define FIELD_RECT_X 1
#define FIELD_RECT_Y 1
#define FIELD_RECT_WIDTH  (LCD_WIDTH - 45)
#define FIELD_RECT_HEIGHT (LCD_HEIGHT - 2)

/* size of the ring of the worm 
   choos a value that is a power of 2 to help 
   the compiler optimize modul operations*/
#define MAX_WORM_SEGMENTS 64   

/* when the game starts */
#define INITIAL_WORM_LENGTH 10 

/* num of pixel the worm grows per eaten food */
#define WORM_PER_FOOD 7        

/* num of worms creeping in the FIELD */
#define MAX_WORMS 3            

/* minimal distance between a worm and an argh 
   when a new argh is made */
#define MIN_ARGH_DIST 5

/**
 * All the properties that a worm has.
 */
struct worm {
    /* The worm is stored in a ring of xy coordinates */
    char x[MAX_WORM_SEGMENTS];
    char y[MAX_WORM_SEGMENTS];

    int head;      /* index of the head within the buffer */
    int tail;      /* index of the tail within the buffer */
    int growing;   /* number of cyles the worm still keeps growing */
    bool alive;    /* the worms living state */

    /* direction vector in which the worm moves */
    int dirx; /* only values -1 0 1 allowed */
    int diry; /* only values -1 0 1 allowed */

    /* this method is used to fetch the direction the user
       has selected. It can be one of the values
       human_player1, human_player2, remote_player, virtual_player. 
       All these values are fuctions, that can change the direction 
       of the worm */
    void (*fetch_worm_direction)(struct worm *w);
} worms[MAX_WORMS];

/* stores the highscore - besides it was scored by a virtual player */
static int highscore;

#define MAX_FOOD  5 /* maximal number of food items */
#define FOOD_SIZE 3 /* the width and height of a food */

/* The arrays store the food coordinates  */
static char foodx[MAX_FOOD];
static char foody[MAX_FOOD];

#define MAX_ARGH  100    /* maximal number of argh items */
#define ARGH_SIZE 4      /* the width and height of a argh */
#define ARGHS_PER_FOOD 2 /* number of arghs produced per eaten food */

/* The arrays store the argh coordinates */
static char arghx[MAX_ARGH];
static char arghy[MAX_ARGH];

/* the number of arghs that are currently in use */ 
static int argh_count;

#ifdef DEBUG_WORMLET
/* just a buffer used for debug output */
static char debugout[15];
#endif

/* the number of ticks each game cycle should take */ 
#define SPEED 14

/* the number of active worms (dead or alive) */
static int worm_count = MAX_WORMS;

/* in multiplayer mode: en- / disables the remote worm control
   in singleplayer mode: toggles 4 / 2 button worm control */
static bool use_remote = false;

/* return values of check_collision */
#define COLLISION_NONE 0
#define COLLISION_WORM 1
#define COLLISION_FOOD 2
#define COLLISION_ARGH 3
#define COLLISION_FIELD 4

/* constants for use as directions.
   Note that the values are ordered clockwise.
   Thus increasing / decreasing the values
   is equivalent to right / left turns. */
#define WEST  0
#define NORTH 1
#define EAST  2
#define SOUTH 3

/* direction of human player 1 */
static int player1_dir = EAST; 
/* direction of human player 2 */
static int player2_dir = EAST; 
/* direction of human player 3 */
static int player3_dir = EAST;

/* the number of (human) players that currently
   control a worm */
static int players = 1;

#ifdef DEBUG_WORMLET
static void set_debug_out(char *str){
    strcpy(debugout, str);
}
#endif

/**
 * Returns the direction id in which the worm
 * currently is creeping.
 * @param struct worm *w The worm that is to be investigated. 
 *        w Must not be null.
 * @return int A value 0 <= value < 4
 *         Note the predefined constants NORTH, SOUTH, EAST, WEST
 */
static int get_worm_dir(struct worm *w) {
    int retVal ;
    if (w->dirx == 0) {
        if (w->diry == 1) {
            retVal = SOUTH;
        } else {
            retVal = NORTH;
        }
    } else {
        if (w->dirx == 1) {
            retVal = EAST;
        } else {
            retVal = WEST;
        }
    }
    return retVal;
}

/**
 * Set the direction of the specified worm with a direction id.
 * Increasing the value by 1 means to turn the worm direction
 * to right by 90 degree.
 * @param struct worm *w The worm that is to be altered. w Must not be null.
 * @param int dir The new direction in which the worm is to creep.
 *        dir must be  0 <= dir < 4. Use predefined constants 
 *        NORTH, SOUTH, EAST, WEST
 */
static void set_worm_dir(struct worm *w, int dir) {
    switch (dir) {
        case WEST:
            w->dirx = -1;
            w->diry = 0;
            break;
         case NORTH:
            w->dirx = 0;
            w->diry = - 1;
            break;
        case EAST:
            w->dirx = 1;
            w->diry = 0;
            break;
        case SOUTH:
            w->dirx = 0;
            w->diry = 1;
            break;
   }
}

/**
 * Returns the current length of the worm array. This
 * is also a value for the number of bends that are in the worm.
 * @return int a positive value with 0 <= value < MAX_WORM_SEGMENTS
 */
static int get_worm_array_length(struct worm *w) {
    /* initial simple calculation will be overwritten if wrong. */
    int retVal = w->head - w->tail;

    /* if the worm 'crosses' the boundaries of the ringbuffer */
    if (retVal < 0) {
        retVal = w->head + MAX_WORM_SEGMENTS - w->tail;
    }

    return retVal;
}

/**
 * Returns the score the specified worm. The score is the length
 * of the worm.
 * @param struct worm *w The worm that is to be investigated.
 *        w must not be null.
 * @return int The length of the worm (>= 0).
 */
static int get_score(struct worm *w) {
    int retval = 0;
    int length = get_worm_array_length(w);
    int i;
    for (i = 0; i < length; i++) {

        /* The iteration iterates the length of the worm.
           Here's the conversion to the true indices within the worm arrays. */
        int linestart = (w->tail + i  ) % MAX_WORM_SEGMENTS;
        int lineend   = (linestart + 1) % MAX_WORM_SEGMENTS;
        int startx = w->x[linestart];
        int starty = w->y[linestart];
        int endx = w->x[lineend];
        int endy = w->y[lineend];

        int minimum, maximum;

        if (startx == endx) {
            minimum = MIN(starty, endy);
            maximum = MAX(starty, endy);
        } else {
            minimum = MIN(startx, endx);
            maximum = MAX(startx, endx);
        }
            retval += abs(maximum - minimum);
    }
    return retval;
}

/**
 * Determines wether the line specified by startx, starty, endx, endy intersects
 * the rectangle specified by x, y, width, height. Note that the line must be exactly
 * horizontal or vertical (startx == endx or starty == endy). 
 * @param int startx The x coordinate of the start point of the line.
 * @param int starty The y coordinate of the start point of the line.
 * @param int endx The x coordinate of the end point of the line.
 * @param int endy The y coordinate of the end point of the line.
 * @param int x The x coordinate of the top left corner of the rectangle.
 * @param int y The y coordinate of the top left corner of the rectangle.
 * @param int width The width of the rectangle.
 * @param int height The height of the rectangle.
 * @return bool Returns true if the specified line intersects with the recangle.
 */
static bool line_in_rect(int startx, int starty, int endx, int endy, int x, int y, int width, int height) {
    bool retval = false;
    int simple, simplemin, simplemax;
    int compa, compb, compmin, compmax;
    int temp;
    if (startx == endx) {
        simple = startx;
        simplemin = x;
        simplemax = x + width;

        compa = starty;
        compb = endy;
        compmin = y;
        compmax = y + height;
    } else {
        simple = starty;
        simplemin = y;
        simplemax = y + height;

        compa = startx;
        compb = endx;
        compmin = x;
        compmax = x + width;
    };

    temp = compa;
    compa = MIN(compa, compb);
    compb = MAX(temp, compb);

    if (simplemin <= simple && simple <= simplemax) {
        if ((compmin <= compa && compa <= compmax) ||
            (compmin <= compb && compb <= compmax) ||
            (compa <= compmin && compb >= compmax)) {
            retval = true;
        }
    }
    return retval;
}

/** 
 * Tests wether the specified worm intersects with the rect.
 * @param struct worm *w The worm to be investigated
 * @param int x The x coordinate of the top left corner of the rect
 * @param int y The y coordinate of the top left corner of the rect
 * @param int widht The width of the rect
 * @param int height The height of the rect
 * @return bool Returns true if the worm intersects with the rect
 */
static bool worm_in_rect(struct worm *w, int x, int y, int width, int height) {
    bool retval = false;


    /* get_worm_array_length is expensive -> buffer the value */
    int wormLength = get_worm_array_length(w);
    int i;

    /* test each entry that is part of the worm */
    for (i = 0; i < wormLength && retval == false; i++) {

        /* The iteration iterates the length of the worm.
           Here's the conversion to the true indices within the worm arrays. */
        int linestart = (w->tail + i  ) % MAX_WORM_SEGMENTS;
        int lineend   = (linestart + 1) % MAX_WORM_SEGMENTS;
        int startx = w->x[linestart];
        int starty = w->y[linestart];
        int endx = w->x[lineend];
        int endy = w->y[lineend];

        retval = line_in_rect(startx, starty, endx, endy, x, y, width, height);
    }

    return retval;
}

/**
 * Checks wether a specific food in the food arrays is at the
 * specified coordinates.
 * @param int foodIndex The index of the food in the food arrays
 * @param int x the x coordinate.
 * @param int y the y coordinate.
 * @return Returns true if the coordinate hits the food specified by
 * foodIndex.
 */
static bool specific_food_collision(int foodIndex, int x, int y) {
    bool retVal = false;
    if (x >= foodx[foodIndex]             &&
        x <  foodx[foodIndex] + FOOD_SIZE &&
        y >= foody[foodIndex]             &&
        y <  foody[foodIndex] + FOOD_SIZE) {

        retVal = true;
    }
    return retVal;
}

/**
 * Returns the index of the food that is at the
 * given coordinates. If no food is at the coordinates
 * -1 is returned.
 * @return int  -1 <= value < MAX_FOOD
 */
static int food_collision(int x, int y) {
    int i = 0;
    int retVal = -1;
    for (i = 0; i < MAX_FOOD; i++) {
        if (specific_food_collision(i, x, y)) {
            retVal = i;
            break;
        }
    }
    return retVal;
}

/**
 * Checks wether a specific argh in the argh arrays is at the
 * specified coordinates.
 * @param int arghIndex The index of the argh in the argh arrays
 * @param int x the x coordinate.
 * @param int y the y coordinate.
 * @return Returns true if the coordinate hits the argh specified by
 * arghIndex.
 */
static bool specific_argh_collision(int arghIndex, int x, int y) {

    if ( x >= arghx[arghIndex] &&
         y >= arghy[arghIndex] &&
         x <  arghx[arghIndex] + ARGH_SIZE &&
         y <  arghy[arghIndex] + ARGH_SIZE )
    {
        return true;
    }

    return false;
}

/**
 * Returns the index of the argh that is at the
 * given coordinates. If no argh is at the coordinates
 * -1 is returned.
 * @param int x The x coordinate.
 * @param int y The y coordinate.
 * @return int  -1 <= value < argh_count <= MAX_ARGH
 */
static int argh_collision(int x, int y) {
    int i = 0;
    int retVal = -1;

    /* search for the argh that has the specified coords */
    for (i = 0; i < argh_count; i++) {
        if (specific_argh_collision(i, x, y)) {
            retVal = i;
            break;
        }
    }
    return retVal;
}

/**
 * Checks wether the worm collides with the food at the specfied food-arrays.
 * @param int foodIndex The index of the food in the arrays. Ensure the value is
 * 0 <= foodIndex <= MAX_FOOD
 * @return Returns true if the worm collides with the specified food.
 */
static bool worm_food_collision(struct worm *w, int foodIndex)
{
    bool retVal = false;

    retVal = worm_in_rect(w, foodx[foodIndex], foody[foodIndex], 
                          FOOD_SIZE - 1, FOOD_SIZE - 1);

    return retVal;
}

/**
 * Returns true if the worm hits the argh within the next moves (unless
 * the worm changes it's direction).
 * @param struct worm *w - The worm to investigate
 * @param int argh_idx - The index of the argh 
 * @param int moves - The number of moves that are considered.
 * @return Returns false if the specified argh is not hit within the next
 *         moves.
 */
static bool worm_argh_collision_in_moves(struct worm *w, int argh_idx, int moves){
    bool retVal = false;
    int x1, y1, x2, y2;
    x1 = w->x[w->head];
    y1 = w->y[w->head];

    x2 = w->x[w->head] + moves * w->dirx;
    y2 = w->y[w->head] + moves * w->diry;

    retVal = line_in_rect(x1, y1, x2, y2, arghx[argh_idx], arghy[argh_idx], 
                         ARGH_SIZE, ARGH_SIZE);
    return retVal;
}

/**
 * Checks wether the worm collides with the argh at the specfied argh-arrays.
 * @param int arghIndex The index of the argh in the arrays.
 * Ensure the value is 0 <= arghIndex < argh_count <= MAX_ARGH
 * @return Returns true if the worm collides with the specified argh.
 */
static bool worm_argh_collision(struct worm *w, int arghIndex)
{
    bool retVal = false;

    retVal = worm_in_rect(w, arghx[arghIndex], arghy[arghIndex], 
                          ARGH_SIZE - 1, ARGH_SIZE - 1);

    return retVal;
}

/**
 * Find new coordinates for the food stored in foodx[index], foody[index]
 * that don't collide with any other food or argh
 * @param int index 
 * Ensure that 0 <= index < MAX_FOOD.
 */
static int make_food(int index) {

    int x = 0;
    int y = 0;
    bool collisionDetected = false;
    int tries = 0;
    int i;

    do {
        /* make coordinates for a new food so that
           the entire food lies within the FIELD */
        x = rand() % (FIELD_RECT_WIDTH  - FOOD_SIZE);
        y = rand() % (FIELD_RECT_HEIGHT - FOOD_SIZE);
        tries ++;

        /* Ensure that the new food doesn't collide with any
           existing foods or arghs.
           If one or more corners of the new food hit any existing
           argh or food a collision is detected.
        */
        collisionDetected = 
            food_collision(x                , y                ) >= 0 ||
            food_collision(x                , y + FOOD_SIZE - 1) >= 0 ||
            food_collision(x + FOOD_SIZE - 1, y                ) >= 0 ||
            food_collision(x + FOOD_SIZE - 1, y + FOOD_SIZE - 1) >= 0 ||
            argh_collision(x                , y                ) >= 0 || 
            argh_collision(x                , y + FOOD_SIZE - 1) >= 0 ||
            argh_collision(x + FOOD_SIZE - 1, y                ) >= 0 ||
            argh_collision(x + FOOD_SIZE - 1, y + FOOD_SIZE - 1) >= 0;

        /* use coordinates for further testing */
        foodx[index] = x;
        foody[index] = y;

        /* now test wether we accidently hit the worm with food ;) */
        i = 0;
        for (i = 0; i < worm_count && !collisionDetected; i++) {
            collisionDetected |= worm_food_collision(&worms[i], index);
        }
    }
    while (collisionDetected);
    return tries;
}

/**
 * Clears a food from the lcd buffer.
 * @param int index The index of the food arrays under which
 * the coordinates of the desired food can be found. Ensure 
 * that the value is 0 <= index <= MAX_FOOD.
 */
static void clear_food(int index)
{
    /* remove the old food from the screen */
    lcd_clearrect(foodx[index] + FIELD_RECT_X, 
                  foody[index] + FIELD_RECT_Y, 
                  FOOD_SIZE, FOOD_SIZE);
}

/**
 * Draws a food in the lcd buffer.
 * @param int index The index of the food arrays under which
 * the coordinates of the desired food can be found. Ensure 
 * that the value is 0 <= index <= MAX_FOOD.
 */
static void draw_food(int index)
{
    /* draw the food object */
    lcd_fillrect(foodx[index] + FIELD_RECT_X, 
                 foody[index] + FIELD_RECT_Y, 
                 FOOD_SIZE, FOOD_SIZE);
    lcd_clearrect(foodx[index] + FIELD_RECT_X + 1, 
                  foody[index] + FIELD_RECT_Y + 1, 
                  FOOD_SIZE - 2, FOOD_SIZE - 2);
}

/**
 * Find new coordinates for the argh stored in arghx[index], arghy[index]
 * that don't collide with any other food or argh.
 * @param int index 
 * Ensure that 0 <= index < argh_count < MAX_ARGH.
 */
static int make_argh(int index)
{
    int x = -1; 
    int y = -1; 
    bool collisionDetected = false;
    int tries = 0;
    int i;

    do {
        /* make coordinates for a new argh so that
           the entire food lies within the FIELD */
        x = rand() % (FIELD_RECT_WIDTH  - ARGH_SIZE);
        y = rand() % (FIELD_RECT_HEIGHT - ARGH_SIZE);
        tries ++;

        /* Ensure that the new argh doesn't intersect with any
           existing foods or arghs.
           If one or more corners of the new argh hit any existing
           argh or food an intersection is detected.
        */
        collisionDetected = 
            food_collision(x                , y                ) >= 0 || 
            food_collision(x                , y + ARGH_SIZE - 1) >= 0 ||
            food_collision(x + ARGH_SIZE - 1, y                ) >= 0 ||
            food_collision(x + ARGH_SIZE - 1, y + ARGH_SIZE - 1) >= 0 ||
            argh_collision(x                , y                ) >= 0 || 
            argh_collision(x                , y + ARGH_SIZE - 1) >= 0 ||
            argh_collision(x + ARGH_SIZE - 1, y                ) >= 0 ||
            argh_collision(x + ARGH_SIZE - 1, y + ARGH_SIZE - 1) >= 0;

        /* use the candidate coordinates to make a real argh */
        arghx[index] = x;
        arghy[index] = y;

        /* now test wether we accidently hit the worm with argh ;) */
        for (i = 0; i < worm_count && !collisionDetected; i++) {
            collisionDetected |= worm_argh_collision(&worms[i], index);
            collisionDetected |= worm_argh_collision_in_moves(&worms[i], index, 
                                                              MIN_ARGH_DIST);
        }
    }
    while (collisionDetected);
    return tries;
}

/**
 * Draws an argh in the lcd buffer.
 * @param int index The index of the argh arrays under which
 * the coordinates of the desired argh can be found. Ensure 
 * that the value is 0 <= index < argh_count <= MAX_ARGH.
 */
static void draw_argh(int index)
{
    /* draw the new argh */
    lcd_fillrect(arghx[index] + FIELD_RECT_X, 
                 arghy[index] + FIELD_RECT_Y, 
                 ARGH_SIZE, ARGH_SIZE);
}

static void virtual_player(struct worm *w);
/**
 * Initialzes the specified worm with INITIAL_WORM_LENGTH
 * and the tail at the specified position. The worm will
 * be initialized alive and creeping EAST.
 * @param struct worm *w The worm that is to be initialized
 * @param int x The x coordinate at which the tail of the worm starts.
 *        x must be 0 <= x < FIELD_RECT_WIDTH.
 * @param int y The y coordinate at which the tail of the worm starts
 *        y must be 0 <= y < FIELD_RECT_WIDTH.
 */
static void init_worm(struct worm *w, int x, int y){
        /* initialize the worm size */
        w->head = 1;
        w->tail = 0;

        w->x[w->head] = x + 1;
        w->y[w->head] = y;

        w->x[w->tail] = x;
        w->y[w->tail] = y;

        /* set the initial direction the worm creeps to */
        w->dirx = 1;
        w->diry = 0;

        w->growing = INITIAL_WORM_LENGTH - 1;
        w->alive = true;
        w->fetch_worm_direction = virtual_player;
}

/** 
 * Writes the direction that was stored for
 * human player 1 into the specified worm. This function
 * may be used to be stored in worm.fetch_worm_direction. 
 * The value of 
 * the direction is read from player1_dir.
 * @param struct worm *w - The worm of which the direction 
 * is altered.
 */
static void human_player1(struct worm *w) {
    set_worm_dir(w, player1_dir);
}

/** 
 * Writes the direction that was stored for
 * human player 2 into the specified worm. This function
 * may be used to be stored in worm.fetch_worm_direction. 
 * The value of 
 * the direction is read from player2_dir.
 * @param struct worm *w - The worm of which the direction 
 * is altered.
 */
static void human_player2(struct worm *w) {
    set_worm_dir(w, player2_dir);
}

/** 
 * Writes the direction that was stored for
 * human player using a remote control 
 * into the specified worm. This function
 * may be used to be stored in worm.fetch_worm_direction. 
 * The value of 
 * the direction is read from player3_dir.
 * @param struct worm *w - The worm of which the direction 
 * is altered.
 */
static void remote_player(struct worm *w) {
    set_worm_dir(w, player3_dir);
}

/**
 * Initializes the worm-, food- and argh-arrays, draws a frame,
 * makes some food and argh and display all that stuff.
 */
static void init_wormlet(void)
{
    int i;

    for (i = 0; i< worm_count; i++) {
            /* Initialize all the worm coordinates to center. */
            int x = (int)(FIELD_RECT_WIDTH / 2);
            int y = (int)((FIELD_RECT_HEIGHT - 20)/ 2) + i * 10;

        init_worm(&worms[i], x, y);
    }

    player1_dir = EAST;
    player2_dir = EAST;
    player3_dir = EAST;

    if (players > 0) {
        worms[0].fetch_worm_direction = human_player1;
    }

    if (players > 1) {
        if (use_remote) {
            worms[1].fetch_worm_direction = remote_player;
        } else {
            worms[1].fetch_worm_direction = human_player2;
        }
    }

    if (players > 2) {
        worms[2].fetch_worm_direction = human_player2;
    }

    /* Needed when the game is restarted using BUTTON_ON */
    lcd_clear_display();

    /* make and display some food and argh */
    argh_count = MAX_FOOD;
    for (i = 0; i < MAX_FOOD; i++) {
        make_food(i);
        draw_food(i);
        make_argh(i);
        draw_argh(i);
    }

    /* draw the game field */
    lcd_invertrect(0, 0, FIELD_RECT_WIDTH + 2, FIELD_RECT_HEIGHT + 2);
    lcd_invertrect(1, 1, FIELD_RECT_WIDTH, FIELD_RECT_HEIGHT);

    /* make everything visible */
    lcd_update();
}


/** 
 * Move the worm one step further if it is alive.
 * The direction in which the worm moves is taken from dirx and diry. 
 * move_worm decreases growing if > 0. While the worm is growing the tail
 * is left untouched.
 * @param struct worm *w The worm to move. w must not be NULL.
 */
static void move_worm(struct worm *w)
{
    if (w->alive) {
        /* determine the head point and its precessor */
        int headx = w->x[w->head];
        int heady = w->y[w->head];
        int prehead = (w->head + MAX_WORM_SEGMENTS - 1) % MAX_WORM_SEGMENTS;
        int preheadx = w->x[prehead];
        int preheady = w->y[prehead];

        /* determine the old direction */
        int olddirx;
        int olddiry;
        if (headx == preheadx) {
            olddirx = 0;
            olddiry = (heady > preheady) ? 1 : -1;
        } else {
            olddiry = 0;
            olddirx = (headx > preheadx) ? 1 : -1;
        }

        /* olddir == dir?
           a change of direction means a new segment 
           has been opened */
        if (olddirx != w->dirx ||
            olddiry != w->diry) {
            w->head = (w->head + 1) % MAX_WORM_SEGMENTS;
        }

        /* new head position */
        w->x[w->head] = headx + w->dirx;
        w->y[w->head] = heady + w->diry;


        /* while the worm is growing no tail procession is necessary */
        if (w->growing > 0) {
    /* update the worms grow state */
            w->growing--;
        }
        
        /* if the worm isn't growing the tail has to be dragged */
        else {
            /* index of the end of the tail segment */ 
            int tail_segment_end = (w->tail + 1) % MAX_WORM_SEGMENTS;

            /* drag the end of the tail */
            /* only one coordinate has to be altered. Here it is 
               determined which one */ 
            int dir = 0; /* specifies wether the coord has to be in- or decreased */
            if (w->x[w->tail] == w->x[tail_segment_end]) {
                dir = (w->y[w->tail] - w->y[tail_segment_end] < 0) ? 1 : -1;
                w->y[w->tail] += dir;
            } else {
                dir = (w->x[w->tail] - w->x[tail_segment_end] < 0) ? 1 : -1;
                w->x[w->tail] += dir;
            }

            /* when the tail has been dragged so far that it meets
               the next segment start the tail segment is obsolete and
               must be freed */
            if (w->x[w->tail] == w->x[tail_segment_end] &&
                w->y[w->tail] == w->y[tail_segment_end]){
                
                /* drop the last tail point */
                w->tail = tail_segment_end;
            }
        }
    }
}

/**
 * Draws the head and clears the tail of the worm in 
 * the display buffer. lcd_update() is NOT called thus
 * the caller has to take care that the buffer is displayed.
 */
static void draw_worm(struct worm *w)
{
    /* draw the new head */
    int x = w->x[w->head];
    int y = w->y[w->head];
    if (x >= 0 && x < FIELD_RECT_WIDTH && y >= 0 && y < FIELD_RECT_HEIGHT) {
        lcd_drawpixel(x + FIELD_RECT_X, y + FIELD_RECT_Y);
    }

    /* clear the space behind the worm */
    x = w->x[w->tail] ;
    y = w->y[w->tail] ;
    if (x >= 0 && x < FIELD_RECT_WIDTH && y >= 0 && y < FIELD_RECT_HEIGHT) {
        lcd_clearpixel(x + FIELD_RECT_X, y + FIELD_RECT_Y);
    }
}

/**
 * Checks wether the coordinate is part of the worm. Returns
 * true if any part of the worm was hit - including the head.
 * @param x int The x coordinate 
 * @param y int The y coordinate
 * @return int The index of the worm arrays that contain x, y.
 * Returns -1 if the coordinates are not part of the worm.
 */ 
static int specific_worm_collision(struct worm *w, int x, int y)
{
    int retVal = -1;

    /* get_worm_array_length is expensive -> buffer the value */
    int wormLength = get_worm_array_length(w);
    int i;

    /* test each entry that is part of the worm */
    for (i = 0; i < wormLength && retVal == -1; i++) {

        /* The iteration iterates the length of the worm.
           Here's the conversion to the true indices within the worm arrays. */
        int linestart = (w->tail + i  ) % MAX_WORM_SEGMENTS;
        int lineend   = (linestart + 1) % MAX_WORM_SEGMENTS;
        bool samex = (w->x[linestart] == x) && (w->x[lineend] == x);
        bool samey = (w->y[linestart] == y) && (w->y[lineend] == y);
        if (samex || samey){
            int test, min, max, tmp;

            if (samey) {
                min = w->x[linestart];
                max = w->x[lineend];
                test = x; 
            } else {
                min = w->y[linestart];
                max = w->y[lineend];
                test = y;
            }

            tmp = min;
            min = MIN(min, max);
            max = MAX(tmp, max);

            if (min <= test && test <= max) {
                retVal = lineend;
            }
        }
    }
    return retVal;
}

/**
 * Increases the length of the specified worm by marking 
 * that it may grow by len pixels. Note that the worm has
 * to move to make the growing happen.
 * @param worm *w The worm that is to be altered.
 * @param int len A positive value specifying the amount of
 * pixels the worm may grow.
 */
static void add_growing(struct worm *w, int len) {
    w->growing += len;
}

/**
 * Determins the worm that is at the coordinates x, y. The parameter
 * w is a switch parameter that changes the functionality of worm_collision.
 * If w is specified and x,y hits the head of w NULL is returned.
 * This is a useful way to determine wether the head of w hits 
 * any worm but including itself but excluding its own head. 
 * (It hits always its own head ;))
 * If w is set to NULL worm_collision returns any worm including all heads
 * that is at position of x,y.
 * @param struct worm *w The worm of which the head should be excluded in
 * the test. w may be set to NULL.
 * @param int x The x coordinate that is checked
 * @param int y The y coordinate that is checkec
 * @return struct worm*  The worm that has been hit by x,y. If no worm
 * was at the position NULL is returned.
 */
static struct worm* worm_collision(struct worm *w, int x, int y){
    struct worm *retVal = NULL;
    int i;
    for (i = 0; (i < worm_count) && (retVal == NULL); i++) {
        int collision_at = specific_worm_collision(&worms[i], x, y);
        if (collision_at != -1) {
            if (!(w == &worms[i] && collision_at == w->head)){
                retVal = &worms[i];
            }
        }
    }
    return retVal;
}

/**
 * Returns true if the head of the worm just has
 * crossed the field boundaries. 
 * @return bool true if the worm just has wrapped.
 */ 
static bool field_collision(struct worm *w)
{
    bool retVal = false;
    if ((w->x[w->head] >= FIELD_RECT_WIDTH)  ||
        (w->y[w->head] >= FIELD_RECT_HEIGHT) ||
        (w->x[w->head] < 0)                  ||
        (w->y[w->head] < 0))
    {
        retVal = true;
    }
    return retVal;
}


/**
 * Returns true if the specified coordinates are within the 
 * field specified by the FIELD_RECT_XXX constants.
 * @param int x The x coordinate of the point that is investigated
 * @param int y The y coordinate of the point that is investigated
 * @return bool Returns false if x,y specifies a point outside the 
 * field of worms.
 */
static bool is_in_field_rect(int x, int y) {
    bool retVal = false;
    retVal = (x >= 0 && x < FIELD_RECT_WIDTH &&
              y >= 0 && y < FIELD_RECT_HEIGHT);
    return retVal;
}

/**
 * Checks and returns wether the head of the w
 * is colliding with something currently.
 * @return int One of the values:
 *   COLLISION_NONE
 *   COLLISION_w
 *   COLLISION_FOOD
 *   COLLISION_ARGH
 *   COLLISION_FIELD
 */
static int check_collision(struct worm *w)
{
    int retVal = COLLISION_NONE;

    if (worm_collision(w, w->x[w->head], w->y[w->head]) != NULL)
        retVal = COLLISION_WORM;

    if (food_collision(w->x[w->head], w->y[w->head]) >= 0)
        retVal = COLLISION_FOOD;

    if (argh_collision(w->x[w->head], w->y[w->head]) >= 0)
        retVal = COLLISION_ARGH;

    if (field_collision(w))
        retVal = COLLISION_FIELD;

    return retVal;
}

/**
 * Returns the index of the food that is closest to the point
 * specified by x, y. This index may be used in the foodx and 
 * foody arrays.
 * @param int x The x coordinate of the point
 * @param int y The y coordinate of the point
 * @return int A value usable as index in foodx and foody.
 */
static int get_nearest_food(int x, int y){
    int nearestfood = 0;
    int olddistance = FIELD_RECT_WIDTH + FIELD_RECT_HEIGHT;
    int deltax = 0;
    int deltay = 0;
    int foodindex;
    for (foodindex = 0; foodindex < MAX_FOOD; foodindex++) {
        int distance;
        deltax = foodx[foodindex] - x;
        deltay = foody[foodindex] - y;
        deltax = deltax > 0 ? deltax : deltax * (-1);
        deltay = deltay > 0 ? deltay : deltay * (-1);
        distance = deltax + deltay;

        if (distance < olddistance) {
            olddistance = distance;
            nearestfood = foodindex;
        }
    }
    return nearestfood;
}

/** 
 * Returns wether the specified position is next to the worm
 * and in the direction the worm looks. Use this method to 
 * test wether this position would be hit with the next move of 
 * the worm unless the worm changes its direction.
 * @param struct worm *w - The worm to be investigated
 * @param int x - The x coordinate of the position to test.
 * @param int y - The y coordinate of the position to test.
 * @return Returns true if the worm will hit the position unless
 * it change its direction before the next move.
 */
static bool is_in_front_of_worm(struct worm *w, int x, int y) {
    bool infront = false;
    int deltax = x - w->x[w->head];
    int deltay = y - w->y[w->head];

    if (w->dirx == 0) {
        infront = (w->diry * deltay) > 0;
    } else {
        infront = (w->dirx * deltax) > 0;
    }
    return infront;
}

/**
 * Returns true if the worm will collide with the next move unless
 * it changes its direction.
 * @param struct worm *w - The worm to be investigated.
 * @return Returns true if the worm will collide with the next move
 * unless it changes its direction.
 */
static bool will_worm_collide(struct worm *w) {
    int x = w->x[w->head] + w->dirx;
    int y = w->y[w->head] + w->diry;
    bool retVal = !is_in_field_rect(x, y);
    if (!retVal) {
        retVal = (argh_collision(x, y) != -1);
    }
    
    if (!retVal) {
        retVal = (worm_collision(w, x, y) != NULL);
    }
    return retVal;
}

/** 
 * This function
 * may be used to be stored in worm.fetch_worm_direction for
 * worms that are not controlled by humans but by artificial stupidity. 
 * A direction is searched that doesn't lead to collision but to the nearest
 * food - but not very intelligent. The direction is written to the specified
 * worm.
 * @param struct worm *w - The worm of which the direction 
 * is altered.
 */
static void virtual_player(struct worm *w) {
    bool isright;
    int plana, planb, planc;
    /* find the next lunch */
    int nearestfood = get_nearest_food(w->x[w->head], w->y[w->head]);

    /* determine in which direction it is */

    /* in front of me? */
    bool infront = is_in_front_of_worm(w, foodx[nearestfood], foody[nearestfood]);

    /* left right of me? */
    int olddir = get_worm_dir(w);
    set_worm_dir(w, (olddir + 1) % 4);
    isright = is_in_front_of_worm(w, foodx[nearestfood], foody[nearestfood]);
    set_worm_dir(w, olddir);

    /* detect situation, set strategy */
    if (infront) {
        if (isright) {
            plana = olddir;
            planb = (olddir + 1) % 4;
            planc = (olddir + 3) % 4;
        } else {
            plana = olddir;
            planb = (olddir + 3) % 4;
            planc = (olddir + 1) % 4;
        }
    } else {
        if (isright) {
            plana = (olddir + 1) % 4;
            planb = olddir;
            planc = (olddir + 3) % 4;
        } else {
            plana = (olddir + 3) % 4;
            planb = olddir;
            planc = (olddir + 1) % 4;
        }
    }

    /* test for collision */
    set_worm_dir(w, plana);
    if (will_worm_collide(w)){

        /* plan b */
        set_worm_dir(w, planb);

        /* test for collision */
        if (will_worm_collide(w)) {

            /* plan c */
            set_worm_dir(w, planc);
        }
    }
}

/**
 * prints out the score board with all the status information
 * about the game.
 */
static void score_board(void)
{
    char buf[15];
    char buf2[15];
    int i;
    int y = 0;
    lcd_clearrect(FIELD_RECT_WIDTH + 2, 0, LCD_WIDTH - FIELD_RECT_WIDTH - 2, LCD_HEIGHT);
    for (i = 0; i < worm_count; i++) {
        int score = get_score(&worms[i]);
    
        /* high score */
        if (worms[i].fetch_worm_direction != virtual_player){
            if (highscore < score) {
                highscore = score;
            }
        }

    /* length */
        snprintf(buf, sizeof (buf),str(LANG_WORMLET_LENGTH), score);

        /* worm state */
        switch (check_collision(&worms[i])) {
        case COLLISION_NONE:  
                if (worms[i].growing > 0){
                    snprintf(buf2, sizeof(buf2), str(LANG_WORMLET_GROWING));
                }
                else {
                    if (worms[i].alive) {
                        snprintf(buf2, sizeof(buf2), str(LANG_WORMLET_HUNGRY));
                    } else {
                        snprintf(buf2, sizeof(buf2), str(LANG_WORMLET_WORMED));
                    }
                }
            break;

        case COLLISION_WORM:  
                snprintf(buf2, sizeof(buf2), str(LANG_WORMLET_WORMED));
            break;

        case COLLISION_FOOD:  
                snprintf(buf2, sizeof(buf2), str(LANG_WORMLET_GROWING));
            break;

        case COLLISION_ARGH:  
                snprintf(buf2, sizeof(buf2), str(LANG_WORMLET_ARGH));
            break;

        case COLLISION_FIELD: 
                snprintf(buf2, sizeof(buf2), str(LANG_WORMLET_CRASHED));
            break;
    }
        lcd_putsxy(FIELD_RECT_WIDTH + 3, y  , buf);
        lcd_putsxy(FIELD_RECT_WIDTH + 3, y+8, buf2);

        if (!worms[i].alive){
            lcd_invertrect(FIELD_RECT_WIDTH + 2, y, 
                           LCD_WIDTH - FIELD_RECT_WIDTH - 2, 17);
        }
        y += 19;
    }
    snprintf(buf , sizeof(buf), str(LANG_WORMLET_HIGHSCORE), highscore);
#ifndef DEBUG_WORMLET
    lcd_putsxy(FIELD_RECT_WIDTH + 3, LCD_HEIGHT - 8, buf);
#else
    lcd_putsxy(FIELD_RECT_WIDTH + 3, LCD_HEIGHT - 8, debugout);
#endif
}

/**
 * Checks for collisions of the worm and its environment and
 * takes appropriate actions like growing the worm or killing it.
 * @return bool Returns true if the worm is dead. Returns
 * false if the worm is healthy, up and creeping.
 */
static bool process_collisions(struct worm *w)
{
    int index = -1;

    w->alive &= !field_collision(w);

    if (w->alive) {

        /* check if food was eaten */
        index = food_collision(w->x[w->head], w->y[w->head]);
        if (index != -1){
            int i;
            
            clear_food(index);
            make_food(index);
            draw_food(index);
            
            for (i = 0; i < ARGHS_PER_FOOD; i++) {
                argh_count++;
                if (argh_count > MAX_ARGH)
                    argh_count = MAX_ARGH;
                make_argh(argh_count - 1);
                draw_argh(argh_count - 1);
            }

            add_growing(w, WORM_PER_FOOD);

            draw_worm(w);
        }

        /* check if argh was eaten */
        else {
            index = argh_collision(w->x[w->head], w->y[w->head]);
            if (index != -1) {
                w->alive = false;
        }
            else {
                if (worm_collision(w, w->x[w->head], w->y[w->head]) != NULL) {
                    w->alive = false;
    }
            }
        }
    }
    return !w->alive;
}

/**
 * The main loop of the game.
 * @return bool Returns true if the game ended
 * with a dead worm. Returns false if the user
 * aborted the game manually.
 */ 
static bool run(void)
{
    int button = 0;
    int wormDead = false;

    /* ticks are counted to compensate speed variations */
    long cycle_start = 0, cycle_end = 0;
#ifdef DEBUG_WORMLET
    int ticks_to_max_cycle_reset = 20;
    long max_cycle = 0;
    char buf[20];
#endif

    /* initialize the board and so on */
    init_wormlet();

    cycle_start = current_tick;
    /* change the direction of the worm */
    while (button != BUTTON_OFF && ! wormDead)
    {
        int i;
        long cycle_duration ;
        switch (button) {
            case BUTTON_UP:
                if (players == 1 && !use_remote) {
                    player1_dir = NORTH;
                }
                break;

            case BUTTON_DOWN:
                if (players == 1 && !use_remote) {
                    player1_dir = SOUTH;
                }
                break;

            case BUTTON_LEFT:
                if (players != 1 || use_remote) {
                    player1_dir = (player1_dir + 3) % 4;
                } else {
                    player1_dir = WEST;
                }
                break;

            case BUTTON_RIGHT:
                if (players != 1 || use_remote) {
                    player1_dir = (player1_dir + 1) % 4;
                } else {
                    player1_dir = EAST;
                }
                break;

            case BUTTON_F2:
                player2_dir = (player2_dir + 3) % 4;
                break;

            case BUTTON_F3:
                player2_dir = (player2_dir + 1) % 4;
                break;

            case BUTTON_VOL_UP:
                player3_dir = (player3_dir + 1) % 4;
                break;

            case BUTTON_VOL_DOWN:
                player3_dir = (player3_dir + 3) % 4;
                break;

            case BUTTON_PLAY:
                do {
                    button = button_get(true);
                } while (button != BUTTON_PLAY &&
                         button != BUTTON_OFF  &&
                         button != BUTTON_ON);
                break;
        }

        for (i = 0; i < worm_count; i++) {
            worms[i].fetch_worm_direction(&worms[i]);
        }

        wormDead = true;
        for (i = 0; i < worm_count; i++){
            struct worm *w = &worms[i];
            move_worm(w);
            wormDead &= process_collisions(w);
            draw_worm(w);
        }
        score_board();
        lcd_update();
        if (button == BUTTON_ON) {
            wormDead = true;
        }

        /* here the wormlet game cycle ends
           thus the current tick is stored
           as end time */
        cycle_end = current_tick;

        /* The duration of the game cycle */
        cycle_duration = cycle_end - cycle_start;
        cycle_duration = MAX(0, cycle_duration);
        cycle_duration = MIN(SPEED -1, cycle_duration);


#ifdef DEBUG_WORMLET
        ticks_to_max_cycle_reset--;
        if (ticks_to_max_cycle_reset <= 0) {
            max_cycle = 0;
        }

        if (max_cycle < cycle_duration) {
            max_cycle = cycle_duration;
            ticks_to_max_cycle_reset = 20;
        }
        snprintf(buf, sizeof buf, "ticks %d", max_cycle);
        set_debug_out(buf);
#endif
        /* adjust the number of ticks to wait for a button.
           This ensures that a complete game cycle including
           user input runs in constant time */
        button = button_get_w_tmo(SPEED - cycle_duration);
        cycle_start = current_tick;

    }
    return wormDead;
}

#ifdef DEBUG_WORMLET

/**
 * Just a test routine that checks that worm_food_collision works
 * in some typical situations.
 */
static void test_worm_food_collision(void) {
    int collision_count = 0;
    int i;
    lcd_clear_display();
    init_worm(&worms[0], 10, 10);
    add_growing(&worms[0], 10);
    set_worm_dir(&worms[0], EAST);
    for (i = 0; i < 10; i++) {
        move_worm(&worms[0]);
        draw_worm(&worms[0]);
    }

    set_worm_dir(&worms[0], SOUTH);
    for (i = 0; i < 10; i++) {
        move_worm(&worms[0]);
        draw_worm(&worms[0]);
    }

    foodx[0] = 15;
    foody[0] = 12;
    for (foody[0] = 20; foody[0] > 0; foody[0] --) {
        char buf[20];
        bool collision;
        draw_worm(&worms[0]);
        draw_food(0);
        collision = worm_food_collision(&worms[0], 0);
        if (collision) {
            collision_count++;
        }
        snprintf(buf, sizeof buf, "collisions: %d", collision_count);
        lcd_putsxy(0, LCD_HEIGHT -8, buf);
        lcd_update();
    }
    if (collision_count != FOOD_SIZE) {
        button_get(true);
    }


    foody[0] = 15;
    for (foodx[0] = 30; foodx[0] > 0; foodx[0] --) {
        char buf[20];
        bool collision;
        draw_worm(&worms[0]);
        draw_food(0);
        collision = worm_food_collision(&worms[0], 0);
        if (collision) {
            collision_count ++;
        }
        snprintf(buf, sizeof buf, "collisions: %d", collision_count);
        lcd_putsxy(0, LCD_HEIGHT -8, buf);
        lcd_update();
    }
    if (collision_count != FOOD_SIZE * 2) {
        button_get(true);
    }

}


static bool expensive_worm_in_rect(struct worm *w, int rx, int ry, int rw, int rh){
    int x, y;
    bool retVal = false;
    for (x = rx; x < rx + rw; x++){
        for (y = ry; y < ry + rh; y++) {
            if (specific_worm_collision(w, x, y) != -1) {
                retVal = true;
            }
        }
    }
    return retVal;
}

static void test_worm_argh_collision(void) {
    int i;
    int dir;
    int collision_count = 0;
    lcd_clear_display();
    init_worm(&worms[0], 10, 10);
    add_growing(&worms[0], 40);
    for (dir = 0; dir < 4; dir++) {
        set_worm_dir(&worms[0], (EAST + dir) % 4);
        for (i = 0; i < 10; i++) {
            move_worm(&worms[0]);
            draw_worm(&worms[0]);
        }
    }

    arghx[0] = 12;
    for (arghy[0] = 0; arghy[0] < FIELD_RECT_HEIGHT - ARGH_SIZE; arghy[0]++){
        char buf[20];
        bool collision;
        draw_argh(0);
        collision = worm_argh_collision(&worms[0], 0);
        if (collision) {
            collision_count ++;
        }
        snprintf(buf, sizeof buf, "collisions: %d", collision_count);
        lcd_putsxy(0, LCD_HEIGHT -8, buf);
        lcd_update();
    }
    if (collision_count != ARGH_SIZE * 2) {
        button_get(true);
    }

    arghy[0] = 12;
    for (arghx[0] = 0; arghx[0] < FIELD_RECT_HEIGHT - ARGH_SIZE; arghx[0]++){
        char buf[20];
        bool collision;
        draw_argh(0);
        collision = worm_argh_collision(&worms[0], 0);
        if (collision) {
            collision_count ++;
        }
        snprintf(buf, sizeof buf, "collisions: %d", collision_count);
        lcd_putsxy(0, LCD_HEIGHT -8, buf);
        lcd_update();
    }
    if (collision_count != ARGH_SIZE * 4) {
        button_get(true);
    }
}

static int testline_in_rect(void) {
    int testfailed = -1;

    int rx = 10;
    int ry = 15;
    int rw = 20;
    int rh = 25;

    /* Test 1 */
    int x1 = 12;
    int y1 = 8;
    int x2 = 12;
    int y2 = 42;

    if (!line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
        !line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_update();
        lcd_putsxy(0, 0, "failed 1");
        button_get(true);
        testfailed = 1;
    }

    /* test 2 */
    y2 = 20;
    if (!line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
        !line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 2");
        lcd_update();
        button_get(true);
        testfailed = 2;
    }

    /* test 3 */
    y1 = 30;
    if (!line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
        !line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 3");
        lcd_update();
        button_get(true);
        testfailed = 3;
    }

    /* test 4 */
    y2 = 45;
    if (!line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
        !line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 4");
        lcd_update();
        button_get(true);
        testfailed = 4;
    }

    /* test 5 */
    y1 = 50;
    if (line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) ||
        line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 5");
        lcd_update();
        button_get(true);
        testfailed = 5;
    }

    /* test 6 */
    y1 = 5;
    y2 = 7;
    if (line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) ||
        line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 6");
        lcd_update();
        button_get(true);
        testfailed = 6;
    }

    /* test 7 */
    x1 = 8;
    y1 = 20;
    x2 = 35;
    y2 = 20;
    if (!line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
        !line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 7");
        lcd_update();
        button_get(true);
        testfailed = 7;
    }

    /* test 8 */
    x2 = 12;
    if (!line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
        !line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 8");
        lcd_update();
        button_get(true);
        testfailed = 8;
    }

    /* test 9 */
    x1 = 25;
    if (!line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
        !line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 9");
        lcd_update();
        button_get(true);
        testfailed = 9;
    }

    /* test 10 */
    x2 = 37;
    if (!line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
        !line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 10");
        lcd_update();
        button_get(true);
        testfailed = 10;
    }

    /* test 11 */
    x1 = 42;
    if (line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) ||
        line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 11");
        lcd_update();
        button_get(true);
        testfailed = 11;
    }

    /* test 12 */
    x1 = 5;
    x2 = 7;
    if (line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) ||
        line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh)) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 12");
        lcd_update();
        button_get(true);
        testfailed = 12;
    }

    /* test 13 */
    rx = 9;
    ry = 15;
    rw = FOOD_SIZE;
    rh = FOOD_SIZE;

    x1 = 10;
    y1 = 10;
    x2 = 10;
    y2 = 20;
    if (!(line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
          line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh))) {
        lcd_drawrect(rx, ry, rw, rh);
        lcd_drawline(x1, y1, x2, y2);
        lcd_putsxy(0, 0, "failed 13");
        lcd_update();
        button_get(true);
        testfailed = 13;
    }

    /* test 14 */
    rx = 9;
    ry = 15;
    rw = 4;
    rh = 4;

    x1 = 10;
    y1 = 10;
    x2 = 10;
    y2 = 19;
    if (!(line_in_rect(x1, y1, x2, y2, rx, ry, rw, rh) &&
          line_in_rect(x2, y2, x1, y1, rx, ry, rw, rh))) {
        lcd_drawline(x1, y1, x2, y2);
        lcd_invertrect(rx, ry, rw, rh);
        lcd_putsxy(0, 0, "failed 14");
        lcd_update();
        button_get(true);
        testfailed = 14;
    }

    lcd_clear_display();

    return testfailed;
}

/**
 * Just a test routine to test wether specific_worm_collision might work properly
 */
static int test_specific_worm_collision(void) {
    int collisions = 0;
    int dir;
    int x = 0;
    int y = 0;
    char buf[20];
    lcd_clear_display();
    init_worm(&worms[0], 10, 20);
    add_growing(&worms[0], 20 - INITIAL_WORM_LENGTH);

    for (dir = EAST; dir < EAST + 4; dir++) {
        int i;
        set_worm_dir(&worms[0], dir % 4);
        for (i = 0; i < 5; i++) {
            if (!(dir % 4 == NORTH && i == 9)) {
                move_worm(&worms[0]);
                draw_worm(&worms[0]);
            }
        }
    }

    for (y = 15; y < 30; y ++){
        for (x = 5; x < 20; x++) {
            if (specific_worm_collision(&worms[0], x, y) != -1) {
                collisions ++;
            }
            lcd_invertpixel(x + FIELD_RECT_X, y + FIELD_RECT_Y);
            snprintf(buf, sizeof buf, "collisions %d", collisions);
            lcd_putsxy(0, LCD_HEIGHT - 8, buf);
            lcd_update();
        }
    }
    if (collisions != 21) {
        button_get(true);
    }
    return collisions;
}

static void test_make_argh(void){
    int dir;
    int seed = 0;
    int hit = 0;
    int failures = 0;
    int last_failures = 0;
    int i, worm_idx;
    lcd_clear_display();
    worm_count = 3;

    for (worm_idx = 0; worm_idx < worm_count; worm_idx++) {
        init_worm(&worms[worm_idx], 10 + worm_idx * 20, 20);
        add_growing(&worms[worm_idx], 40 - INITIAL_WORM_LENGTH);
    }

    for (dir = EAST; dir < EAST + 4; dir++) {
        for (worm_idx = 0; worm_idx < worm_count; worm_idx++) {
            set_worm_dir(&worms[worm_idx], dir % 4);
        for (i = 0; i < 10; i++) {
            if (!(dir % 4 == NORTH && i == 9)) {
                    move_worm(&worms[worm_idx]);
                    draw_worm(&worms[worm_idx]);
                }
            }
        }
    }

    lcd_update();

    for (seed = 0; hit < 20; seed += 2) {
            char buf[20];
        int x, y;
        srand(seed);
        x = rand() % (FIELD_RECT_WIDTH  - ARGH_SIZE);
        y = rand() % (FIELD_RECT_HEIGHT - ARGH_SIZE);

        for (worm_idx = 0; worm_idx < worm_count; worm_idx++){
            if (expensive_worm_in_rect(&worms[worm_idx], x, y, ARGH_SIZE, ARGH_SIZE)) {
                int tries = 0;
            srand(seed);

                tries = make_argh(0);
                if ((x == arghx[0] && y == arghy[0]) || tries < 2) {
                failures ++;
            }

                snprintf(buf, sizeof buf, "(%d;%d) fail%d try%d", x, y, failures, tries);
            lcd_putsxy(0, LCD_HEIGHT - 8, buf);
            lcd_update();
                lcd_invertrect(x + FIELD_RECT_X, y+ FIELD_RECT_Y, ARGH_SIZE, ARGH_SIZE);
                lcd_update();
                draw_argh(0);
                lcd_update();
            lcd_invertrect(x + FIELD_RECT_X, y + FIELD_RECT_Y, ARGH_SIZE, ARGH_SIZE);
            lcd_clearrect(arghx[0] + FIELD_RECT_X, arghy[0] + FIELD_RECT_Y, ARGH_SIZE, ARGH_SIZE);

                if (failures > last_failures) {
                button_get(true);
            }
                last_failures = failures;
            hit ++;
        }
    }
    }
}

static void test_worm_argh_collision_in_moves(void) {
    int hit_count = 0;
    int i;
    lcd_clear_display();
    init_worm(&worms[0], 10, 20);

    arghx[0] = 20;
    arghy[0] = 18;
    draw_argh(0);

    set_worm_dir(&worms[0], EAST);
    for (i = 0; i < 20; i++) {
        char buf[20];
        move_worm(&worms[0]);
        draw_worm(&worms[0]);
        if (worm_argh_collision_in_moves(&worms[0], 0, 5)){
            hit_count ++;
        }
        snprintf(buf, sizeof buf, "in 5 moves hits: %d", hit_count);
        lcd_putsxy(0, LCD_HEIGHT - 8, buf);
        lcd_update();
    }    
    if (hit_count != ARGH_SIZE + 5) {
        button_get(true);
    }    
}
#endif /* DEBUG_WORMLET */

extern bool use_old_rect;

/**
 * Main entry point from the menu to start the game control.
 */
bool wormlet(void)
{
    bool worm_dead = false;
    int button;
    
    lcd_setfont(FONT_SYSFIXED);

#ifdef DEBUG_WORMLET
    testline_in_rect();
    test_worm_argh_collision_in_moves();
    test_make_argh();
    test_worm_food_collision();
    test_worm_argh_collision();
    test_specific_worm_collision();
#endif 
    lcd_setmargins(0,0);

    /* Setup screen */
    do {
        char buf[20];
        lcd_clear_display();

        /* first line players */
        snprintf(buf, sizeof buf, str(LANG_WORMLET_PLAYERS), players);
        lcd_puts(0, 0, buf);

        /* second line worms */
        snprintf(buf, sizeof buf, str(LANG_WORMLET_WORMS), worm_count);
        lcd_puts(0, 1, buf);

        /* third line control */
        if (players > 1) {
            if (use_remote) {
                snprintf(buf, sizeof buf, str(LANG_WORMLET_REMOTE_CTRL));
            } else {
                snprintf(buf, sizeof buf, str(LANG_WORMLET_NO_REM_CTRL));
            }
        } else {
            if (players > 0) {
                if (use_remote) {
                    snprintf(buf, sizeof buf, str(LANG_WORMLET_2_KEY_CTRL));
                } else {
                    snprintf(buf, sizeof buf, str(LANG_WORMLET_4_KEY_CTRL));
                }
            } else {
                snprintf(buf, sizeof buf, str(LANG_WORMLET_NO_CONTROL));
            }
        }
        lcd_puts(0, 2, buf);
        lcd_update();

        /* user selection */
        button = button_get(true);
        switch (button) {
            case BUTTON_UP:
                if (players < 3) {
                    players ++;
                    if (players > worm_count) {
                        worm_count = players;
                    }
                    if (players > 2) {
                        use_remote = true;
                    }
                }
                break;
            case BUTTON_DOWN:
                if (players > 0) {
                    players --;
                }
                break;
            case BUTTON_LEFT: 
                if (worm_count > 1) {
                    worm_count--;
                    if (worm_count < players) {
                        players = worm_count;
                    }
                }
                break;
            case BUTTON_RIGHT:
                if (worm_count < MAX_WORMS) {
                    worm_count ++;
                }
                break;
            case BUTTON_F1:
                use_remote = !use_remote;
                if (players > 2) {
                    use_remote = true;
                }
                break;

            case SYS_USB_CONNECTED:
                usb_screen();
                lcd_setfont(FONT_UI);
                return true;
        }
    } while (button != BUTTON_PLAY && 
             button != BUTTON_OFF  && button != BUTTON_ON);

    lcd_clear_display();
    /* end of setup */

    do {    

        /* button state will be overridden if
           the game quits with the death of the worm.
           Initializing button to BUTTON_OFF ensures
           that the user can hit BUTTON_OFF during the
           game to return to the menu.
        */
        button  = BUTTON_OFF;

        /* start the game */
        worm_dead = run();

        /* if worm isn't dead the game was quit
           via BUTTON_OFF -> no need to wait for buttons. */
        if (worm_dead) {
            do {
                button = button_get(true);
            }
            /* BUTTON_ON -> start new game */
            /* BUTTON_OFF -> back to game menu */
            while (button != BUTTON_OFF && button != BUTTON_ON);
        }
    }
    while (button != BUTTON_OFF);

    lcd_setfont(FONT_UI);

    return false;
}


#endif /* USE_GAMES */