Subversion Repositories Code-Repo

#include "defines.h"
#include "CONTROLLERS.h"
#include "SNAKE.h"
#include "TIMER4.h"

static SNAKE_DATA *data_p;
static uint32_t rand_value __attribute__((persistent));

void Snake_Init(SNAKE_DATA *data) {
    data_p = data;

    // Set starting point
    data_p->body[0] = (SNAKE_POINT){0,0,7};

    data_p->pos_head = 0;
    data_p->pos_tail = 0;
    data_p->length = 1;
    data_p->level = 0;
    data_p->delay = SNAKE_MAXIMUM_DELAY;
    data_p->direction = (SNAKE_POINT){1,0,7};
    data_p->last_direction = 0x08;

    srand(rand_value);

    // Generate a starting location for the candy
    data_p->candy_loc = Snake_Generate_Candy();

    // Draw the snake (head)
    Cube_Clear();
    uint32_t index = data_p->pos_head;
    Cube_Set_Pixel(data_p->body[index].z, data_p->body[index].x, data_p->body[index].y, SNAKE_HEAD_COLOR);
    while (index != data_p->pos_tail) {
        if (data_p->length > 1) {
            index = (index == 0) ? CUBE_PIXELS - 1 : index - 1;
            Cube_Set_Pixel(data_p->body[index].z, data_p->body[index].x, data_p->body[index].y, SNAKE_BODY_COLOR);
        }
    }
}

void Snake_Main(void) {
    // Main function, loops and delays while updating the frame every x milliseconds

    while(!Controller_Get_Connected()) {
        Delay_MS(100);
        Controller_Poll_Connected();
    }

    Controller_Set_Active(0);
    Delay_MS(20);
    Controller_Set_Left_Leds(0, 0x1);
    TIMER4_Start();
    Delay_MS(1000);
    while (1) {
        // Regenerate the seed upon each update so that the candy starts somewhere new every time
        rand_value = rand();

        Snake_Update_Frame();
        Delay_MS(data_p->delay);
    }
}

void Snake_Update_Direction(uint8_t controller, CTRL_BTN_STATUS value) {
    // Determine the next direction for the snake based off the last button press
    if (controller == 0) {
        data_p->last_direction = value.w;
        SNAKE_POINT point = data_p->body[data_p->pos_head];

        if (value.BTN_L_N || value.BTN_L_E) {    // Up
            point.z = (point.z == CUBE_LAYER_COUNT - 1) ? 0 : point.z + 1;
        } else if (value.BTN_L_W || value.BTN_L_S) { // Down
            point.z = (point.z == 0) ? CUBE_LAYER_COUNT - 1 : point.z - 1;
        } else if (value.BTN_R_N) { // Forward
            point.x = (point.x == CUBE_ROW_COUNT - 1) ? 0 : point.x + 1;
        } else if (value.BTN_R_W) { // Right
            point.y = (point.y == CUBE_COLUMN_COUNT - 1) ? 0 : point.y + 1;
        } else if (value.BTN_R_S) { // Backward
            point.x = (point.x == 0) ? CUBE_ROW_COUNT - 1 : point.x - 1;
        } else if (value.BTN_R_E) { // Left
            point.y = (point.y== 0) ? CUBE_COLUMN_COUNT - 1 : point.y - 1;
        }

        data_p->direction = point;
    }

    // Update the overlay with the candy location
    Cube_Overlay_Clear();
    Cube_Overlay_Set_Pixel(data_p->candy_loc.z, data_p->candy_loc.x, data_p->candy_loc.y, SNAKE_CANDY_COLOR);
}

void Snake_Update_Frame(void) {
    uint8_t om_nom_nom = 0;

    // Check if we are moving onto a candy, if so extend body
    if (data_p->direction.x == data_p->candy_loc.x &&
            data_p->direction.y == data_p->candy_loc.y &&
            data_p->direction.z == data_p->candy_loc.z) {
        data_p->pos_head = (data_p->pos_head == CUBE_PIXELS - 1) ? 0 : data_p->pos_head + 1;
        data_p->body[data_p->pos_head] = data_p->direction;
        data_p->length++;
        data_p->candy_loc = Snake_Generate_Candy();
        om_nom_nom = 1;
    }

    // Check if the location that we are moving to is overlapping the body
    uint32_t pos = data_p->pos_tail;
    while (pos != data_p->pos_head) {
        if (data_p->direction.x == data_p->body[pos].x &&
                data_p->direction.y == data_p->body[pos].y &&
                data_p->direction.z == data_p->body[pos].z) {
            // Indicate the overlapping pixel, delay, then return to idle state
            Cube_Set_Pixel(data_p->direction.z, data_p->direction.x, data_p->direction.y, SNAKE_COLLISION_COLOR);
            Delay_MS(3000);
            Cube_Overlay_Clear();
            Animation_Cube_In_Out(200, ORANGE);
            Reset_Board(BOARD_MODE_IDLE);
        }
        pos = (pos == CUBE_PIXELS - 1) ? 0 : pos + 1;
    }

    // If we didnt eat a candy, increment the frame to move the body along
    if (!om_nom_nom) {
        data_p->pos_head = (data_p->pos_head == CUBE_PIXELS - 1) ? 0 : data_p->pos_head + 1;
        data_p->pos_tail = (data_p->pos_tail == CUBE_PIXELS - 1) ? 0 : data_p->pos_tail + 1;
        data_p->body[data_p->pos_head] = data_p->direction;
    }

    // Draw updated snake location
    Cube_Clear();
    uint32_t index = data_p->pos_head;
    Cube_Set_Pixel(data_p->body[index].z, data_p->body[index].x, data_p->body[index].y, SNAKE_HEAD_COLOR);
    while (index != data_p->pos_tail) {
        if (data_p->length > 1) {
            index = (index == 0) ? CUBE_PIXELS - 1 : index - 1;
            Cube_Set_Pixel(data_p->body[index].z, data_p->body[index].x, data_p->body[index].y, SNAKE_BODY_COLOR);
        }
    }

    // Determine the next direction to take
    Snake_Update_Direction(0, (CTRL_BTN_STATUS)data_p->last_direction);

    // If we ate a candy, delay for a bit to rest
    if (om_nom_nom) {
        // Increase the level by one
        data_p->level += 1;

        TIMER4_Stop();
        Controller_Set_Middle_Leds(0, data_p->level);
        if (data_p->level >= 256)
            Controller_Set_Left_Leds(0, 0x9);
        TIMER4_Start();

        // Decrease the delay between frame updates by 5ms
        if (data_p->delay > SNAKE_MINIMUM_DELAY)
            data_p->delay -= 5;
        // Clear the watchdog timer to prevent resets in a middle of a game
        ClearWDT();
    }
}

SNAKE_POINT Snake_Generate_Candy(void) {
    // Generates a random position within the cube that doesnt overlap anything
    SNAKE_POINT ret;
    uint32_t x, y, z, brk = 0;
    while(1) {
        x = rand() % 8;
        y = rand() % 8;
        z = rand() % 8;

        if (data_p->length != 1) {
            uint32_t pos = data_p->pos_tail;
            uint32_t overlap = 0;
            // Iterate through the frame till we finish or find an overlap
            while (pos != data_p->pos_head) {
                if (data_p->body[pos].x == x &&
                        data_p->body[pos].y == y &&
                        data_p->body[pos].z == z) {
                    overlap = 1;
                    break;
                } else {
                    pos = (pos == CUBE_PIXELS - 1) ? 0 : pos + 1;
                }
            }
            if (!overlap)
                brk = 1;
        } else {
            uint32_t pos = data_p->pos_tail;
            if (data_p->body[pos].x != x &&
                    data_p->body[pos].y != y &&
                    data_p->body[pos].z != z) {
                brk = 1;
            }
        }

        if (brk)
            break;
    }

    ret.x = x;
    ret.y = y;
    ret.z = z;
    return ret;
}