Subversion Repositories Code-Repo

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

static TRON_DATA *tron_data_p;

void Tron_Init(TRON_DATA *data) {
    tron_data_p = data;

    // Set players 1-4 colors
    tron_data_p->Color_Head_R[0] = 0xFF;
    tron_data_p->Color_Head_G[0] = 0x00;
    tron_data_p->Color_Head_B[0] = 0x00;
    tron_data_p->Color_Body_R[0] = 0x20;
    tron_data_p->Color_Body_G[0] = 0x00;
    tron_data_p->Color_Body_B[0] = 0x00;

    tron_data_p->Color_Head_R[1] = 0x00;
    tron_data_p->Color_Head_G[1] = 0x00;
    tron_data_p->Color_Head_B[1] = 0xFF;
    tron_data_p->Color_Body_R[1] = 0x00;
    tron_data_p->Color_Body_G[1] = 0x00;
    tron_data_p->Color_Body_B[1] = 0x20;

    tron_data_p->Color_Head_R[2] = 0x00;
    tron_data_p->Color_Head_G[2] = 0xFF;
    tron_data_p->Color_Head_B[2] = 0x00;
    tron_data_p->Color_Body_R[2] = 0x00;
    tron_data_p->Color_Body_G[2] = 0x20;
    tron_data_p->Color_Body_B[2] = 0x00;

    tron_data_p->Color_Head_R[3] = 0xFF;
    tron_data_p->Color_Head_G[3] = 0x60;
    tron_data_p->Color_Head_B[3] = 0x00;
    tron_data_p->Color_Body_R[3] = 0x20;
    tron_data_p->Color_Body_G[3] = 0x10;
    tron_data_p->Color_Body_B[3] = 0x00;

//    // Set starting points for players
    tron_data_p->body[0][0] = (TRON_POINT){0,0,7};
    tron_data_p->body[1][0] = (TRON_POINT){7,7,7};
    tron_data_p->body[2][0] = (TRON_POINT){0,7,7};
    tron_data_p->body[3][0] = (TRON_POINT){7,0,7};

    tron_data_p->delay = TRON_DELAY;

    Cube_Clear();
    Cube_Overlay_Clear();

    // Determine the number of players (connected controllers)
    tron_data_p->players = Controller_Get_Connected();
    while (tron_data_p->players < 2) {
        Delay_MS(100);
        Controller_Poll_Connected();
        tron_data_p->players = Controller_Get_Connected();
    }
    if (tron_data_p->players > TRON_MAX_PLAYERS)
        tron_data_p->players = TRON_MAX_PLAYERS;
    tron_data_p->players_alive = tron_data_p->players;

    // Draw each player's light trail
    uint8_t i;
    for (i = 0; i < tron_data_p->players; i++) {
        tron_data_p->length[i] = 1;
        tron_data_p->dead[i] = 0;
        // Draw the head
        Cube_Set_Pixel(tron_data_p->body[i][tron_data_p->length[i] - 1].z,
                tron_data_p->body[i][tron_data_p->length[i] - 1].x,
                tron_data_p->body[i][tron_data_p->length[i] - 1].y,
                tron_data_p->Color_Head_R[i], tron_data_p->Color_Head_G[i],
                tron_data_p->Color_Head_B[i]);
    }

    // Set starting direction for players
    Tron_Update_Direction(0, (CTRL_BTN_STATUS) (uint8_t) 0x08);
    Tron_Update_Direction(1, (CTRL_BTN_STATUS) (uint8_t) 0x10);
    Tron_Update_Direction(2, (CTRL_BTN_STATUS) (uint8_t) 0x04);
    Tron_Update_Direction(3, (CTRL_BTN_STATUS) (uint8_t) 0x20);
}

void Tron_Main(void) {
    // Main function, loops and delays while updating the frame every x milliseconds
    uint8_t i;
    for (i = 0; i < tron_data_p->players; i++) {
        Controller_Set_Active(i);
    }
    Delay_MS(20);
    // Light up the player indicators
    switch (tron_data_p->players) {
        case 4:
            Controller_Set_Left_Leds(3, 0x02);
        case 3:
            Controller_Set_Left_Leds(2, 0x04);
        case 2:
        default:
            Controller_Set_Left_Leds(1, 0x08);
            Controller_Set_Left_Leds(0, 0x01);
            break;
    }
    TIMER4_Start();
    Delay_MS(3000);
    while (1) {
        Tron_Update_Frame();
        Delay_MS(tron_data_p->delay);
    }
}

void Tron_Update_Direction(uint8_t controller, CTRL_BTN_STATUS value) {
    // Determine the next direction for the trails based off the last button press
    if (controller < tron_data_p->players) {
        // Save the current button value
        tron_data_p->last_direction[controller] = value.w;

        // Grab the location of the head
        TRON_POINT next_pos = tron_data_p->body[controller][tron_data_p->length[controller] - 1];

        // Determine which next point to move to
        if (value.BTN_L_N || value.BTN_L_E) {   // Up
            next_pos.z = (next_pos.z == CUBE_LAYER_COUNT - 1) ? 0 : next_pos.z + 1;
        } else if (value.BTN_L_S || value.BTN_L_W) {    // Down
            next_pos.z = (next_pos.z == 0) ? CUBE_LAYER_COUNT - 1 : next_pos.z - 1;
        } else if (value.BTN_R_N) { // Forward
            next_pos.x = (next_pos.x == CUBE_ROW_COUNT - 1) ? 0 : next_pos.x + 1;
        } else if (value.BTN_R_W) { // Left
            next_pos.y = (next_pos.y == CUBE_COLUMN_COUNT - 1) ? 0 : next_pos.y + 1;
        } else if (value.BTN_R_S) { // Backwards
            next_pos.x = (next_pos.x == 0) ? CUBE_ROW_COUNT - 1 : next_pos.x - 1;
//        } else if (value.BTN_R_E) { // Right
        } else { // Right
            next_pos.y = (next_pos.y== 0) ? CUBE_COLUMN_COUNT - 1 : next_pos.y - 1;
        }
        
        // Save the next point to move to
        tron_data_p->direction[controller] = next_pos;
    }
}

void Tron_Update_Frame(void) {
    uint8_t player, player2;

    // Change the current head color to the body color
    for (player = 0; player < tron_data_p->players; player++) {
        if (tron_data_p->dead[player] == 0) {
            Cube_Set_Pixel(tron_data_p->body[player][tron_data_p->length[player] - 1].z,
                    tron_data_p->body[player][tron_data_p->length[player] - 1].x,
                    tron_data_p->body[player][tron_data_p->length[player] - 1].y,
                    tron_data_p->Color_Body_R[player],
                    tron_data_p->Color_Body_G[player],
                    tron_data_p->Color_Body_B[player]);
        }
    }

    // Check if there is a head-on collision between any of the players
    for (player = 0; player < tron_data_p->players; player++) {
        if (tron_data_p->dead[player] == 0) {
            for (player2 = 0; player2 < tron_data_p->players; player2++) {
                if (player2 == player) continue;
                if (tron_data_p->dead[player2] == 0) {
                    if (tron_data_p->direction[player].x == tron_data_p->direction[player2].x &&
                            tron_data_p->direction[player].y == tron_data_p->direction[player2].y &&
                            tron_data_p->direction[player].z == tron_data_p->direction[player2].z) {
                        // Indicate the collision point
                        Cube_Set_Pixel(tron_data_p->direction[player].z, tron_data_p->direction[player].x,
                                tron_data_p->direction[player].y, TRON_COLLISION);
                        // Mark the players as dead
                        tron_data_p->dead[player] = 1;
                        tron_data_p->dead[player2] = 1;
                        tron_data_p->players_alive -= 2;
                    }
                }
            }
        }
    }

    // Check if the location that we are moving to is overlapping either trails
    uint8_t index;
    for (player = 0; player < tron_data_p->players; player++) {
        // Check if the player in question is dead
        if (tron_data_p->dead[player] == 0) {
            // See if the player's next point hits anyone elses trail
            for (player2 = 0; player2 < tron_data_p->players; player2++) {
                for (index = 0; index < tron_data_p->length[player2]; index++) {
                    if (tron_data_p->direction[player].x == tron_data_p->body[player2][index].x &&
                            tron_data_p->direction[player].y == tron_data_p->body[player2][index].y &&
                            tron_data_p->direction[player].z == tron_data_p->body[player2][index].z) {
                        // Indicate the collision point
                        Cube_Set_Pixel(tron_data_p->direction[player].z, tron_data_p->direction[player].x,
                                tron_data_p->direction[player].y, TRON_COLLISION);
                        // Mark the player as dead
                        tron_data_p->dead[player] = 1;
                        tron_data_p->players_alive -= 1;
                    }
                }
            }
        }
    }

    // Save the new head location of each trail
    for (player = 0; player < tron_data_p->players; player++) {
        // If player is still alive, extend its body in the next direction
        if (tron_data_p->dead[player] == 0) {
            tron_data_p->length[player]++;
            tron_data_p->body[player][tron_data_p->length[player] - 1] = tron_data_p->direction[player];
        }
    }

    // Update the head to its corresponding color
    for (player = 0; player < tron_data_p->players; player++) {
        // If player is still alive, recolor its body to indicate its new head
        if (tron_data_p->dead[player] == 0) {
            // Set the color of the new head
            Cube_Set_Pixel(tron_data_p->body[player][tron_data_p->length[player] - 1].z,
                    tron_data_p->body[player][tron_data_p->length[player] - 1].x,
                    tron_data_p->body[player][tron_data_p->length[player] - 1].y,
                    tron_data_p->Color_Head_R[player],
                    tron_data_p->Color_Head_G[player],
                    tron_data_p->Color_Head_B[player]);
        }
    }

    // End the game if there is one player left alive
    if (tron_data_p->players_alive == 1) {
        Delay_MS(5000);
        // Determine which player is still alive and flash his color
        for (player = 0; player < tron_data_p->players; player++) {
            if (tron_data_p->dead[player] == 0) {
                Animation_Cube_In_Out(200, tron_data_p->Color_Head_R[player],
                        tron_data_p->Color_Head_G[player], tron_data_p->Color_Head_B[player]);
            }
        }
        Reset_Board(BOARD_MODE_IDLE);
    } else if (tron_data_p->players_alive == 0) {
        // If no players are alive flash neutral color
        Delay_MS(5000);
        Animation_Cube_In_Out(200, TRON_COLLISION_2);
        Reset_Board(BOARD_MODE_IDLE);
    }

    // Determine the next direction to move to for each player
    for (player = 0; player < tron_data_p->players; player++) {
        if (tron_data_p->dead[player] == 0) {
            Tron_Update_Direction(player, (CTRL_BTN_STATUS)tron_data_p->last_direction[player]);
        }
    }

    // Decrease the delay between frame updates by 5ms
    tron_data_p->delay -= 5;
}