WebSVN – Code-Repo – Diff – /PIC Stuff/Cerebot_32MX7_LED_Cube/TRON.c

 #include "defines.h"
 #include "CONTROLLERS.h"
 #include "TRON.h"
+#include "TIMER4.h"
-static TRON_DATA *data_p;
+static TRON_DATA *tron_data_p;
 void Tron_Init(TRON_DATA *data) {
-    data_p = 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 point
+//    // Set starting points for players
-    data_p->p1_body[0] = (TRON_POINT){0,0,7};
+    tron_data_p->body[0][0] = (TRON_POINT){0,0,7};
-    data_p->p2_body[0] = (TRON_POINT){7,7,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};
-    data_p->length = 1;
-    data_p->delay = 800;
+    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();
-    // Draw player 1 light trail
+    while (tron_data_p->players < 2) {
-    uint32_t index;
+        Delay_MS(100);
-    for (index = 0; index < data_p->length - 1; index++) {
+        Controller_Poll_Connected();
-        Cube_Set_Pixel(data_p->p1_body[index].z, data_p->p1_body[index].x, data_p->p1_body[index].y, TRON_PLAYER_1_COLOR);
+        tron_data_p->players = Controller_Get_Connected();
     }
+    if (tron_data_p->players > TRON_MAX_PLAYERS)
+        tron_data_p->players = TRON_MAX_PLAYERS;
-    Cube_Set_Pixel(data_p->p1_body[data_p->length-1].z, data_p->p1_body[data_p->length-1].x, data_p->p1_body[data_p->length-1].y, TRON_PLAYER_1_HEAD);
+    tron_data_p->players_alive = tron_data_p->players;
-    // Draw player 2 light trail
+    // Draw each player's light trail
+    uint8_t i;
-    for (index = 0; index < data_p->length - 1; index++) {
+    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(data_p->p2_body[index].z, data_p->p2_body[index].x, data_p->p2_body[index].y, TRON_PLAYER_2_COLOR);
+        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);
-    Cube_Set_Pixel(data_p->p2_body[data_p->length-1].z, data_p->p2_body[data_p->length-1].x, data_p->p2_body[data_p->length-1].y, TRON_PLAYER_2_HEAD);
+    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:
-    Tron_Update_Direction(0x04,0x04);
+            Controller_Set_Left_Leds(2, 0x04);
+        case 2:
+        default:
+            Controller_Set_Left_Leds(1, 0x08);
-//    Controller_Set_Leds(0x01,0x01);
+            Controller_Set_Left_Leds(0, 0x01);
+            break;
+    }
+    TIMER4_Start();
-    Delay_MS(2000);
+    Delay_MS(3000);
     while (1) {
         Tron_Update_Frame();
-        Delay_MS(data_p->delay);
+        Delay_MS(tron_data_p->delay);
+    }
+}
-void Tron_Update_Direction(uint8_t p1, uint8_t p2) {
+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 (p1) {
+    if (controller < tron_data_p->players) {
-        TRON_P1_DIRECTION p1_dir;
+        // Save the current button value
-        p1_dir.value = p1;
+        tron_data_p->last_direction[controller] = value.w;
-        data_p->p1_last_direction = p1_dir.value;
+        // Grab the location of the head
-        TRON_POINT p1_point = data_p->p1_body[data_p->length - 1];
+        TRON_POINT next_pos = tron_data_p->body[controller][tron_data_p->length[controller] - 1];
+        // Determine which next point to move to
-        if (p1_dir.up) {
+        if (value.BTN_L_N || value.BTN_L_E) {   // Up
-            p1_point.z = (p1_point.z == CUBE_LAYER_COUNT - 1) ? 0 : p1_point.z + 1;
+            next_pos.z = (next_pos.z == CUBE_LAYER_COUNT - 1) ? 0 : next_pos.z + 1;
-        } else if (p1_dir.down) {
+        } else if (value.BTN_L_S || value.BTN_L_W) {    // Down
-            p1_point.z = (p1_point.z == 0) ? CUBE_LAYER_COUNT - 1 : p1_point.z - 1;
+            next_pos.z = (next_pos.z == 0) ? CUBE_LAYER_COUNT - 1 : next_pos.z - 1;
-        } else if (p1_dir.forward) {
+        } else if (value.BTN_R_N) { // Forward
-            p1_point.x = (p1_point.x == CUBE_ROW_COUNT - 1) ? 0 : p1_point.x + 1;
+            next_pos.x = (next_pos.x == CUBE_ROW_COUNT - 1) ? 0 : next_pos.x + 1;
-        } else if (p1_dir.right) {
+        } else if (value.BTN_R_W) { // Left
-            p1_point.y = (p1_point.y == CUBE_COLUMN_COUNT - 1) ? 0 : p1_point.y + 1;
+            next_pos.y = (next_pos.y == CUBE_COLUMN_COUNT - 1) ? 0 : next_pos.y + 1;
-        } else if (p1_dir.backward) {
+        } else if (value.BTN_R_S) { // Backwards
-            p1_point.x = (p1_point.x == 0) ? CUBE_ROW_COUNT - 1 : p1_point.x - 1;
+            next_pos.x = (next_pos.x == 0) ? CUBE_ROW_COUNT - 1 : next_pos.x - 1;
+//        } else if (value.BTN_R_E) { // Right
-        } else if (p1_dir.left) {
+        } else { // Right
-            p1_point.y = (p1_point.y== 0) ? CUBE_COLUMN_COUNT - 1 : p1_point.y - 1;
+            next_pos.y = (next_pos.y== 0) ? CUBE_COLUMN_COUNT - 1 : next_pos.y - 1;
         }
-        data_p->p1_direction = p1_point;
-    }
-    if (p2) {
-        TRON_P2_DIRECTION p2_dir;
-        p2_dir.value = p2;
-        data_p->p2_last_direction = p2_dir.value;
-        TRON_POINT p2_point = data_p->p2_body[data_p->length - 1];
-        if (p2_dir.up) {
-            p2_point.z = (p2_point.z == CUBE_LAYER_COUNT - 1) ? 0 : p2_point.z + 1;
-        } else if (p2_dir.down) {
+        // Save the next point to move to
-            p2_point.z = (p2_point.z == 0) ? CUBE_LAYER_COUNT - 1 : p2_point.z - 1;
-        } else if (p2_dir.forward) {
-            p2_point.x = (p2_point.x == CUBE_ROW_COUNT - 1) ? 0 : p2_point.x + 1;
-        } else if (p2_dir.right) {
-            p2_point.y = (p2_point.y == CUBE_COLUMN_COUNT - 1) ? 0 : p2_point.y + 1;
-        } else if (p2_dir.backward) {
-            p2_point.x = (p2_point.x == 0) ? CUBE_ROW_COUNT - 1 : p2_point.x - 1;
-        } else if (p2_dir.left) {
-            p2_point.y = (p2_point.y== 0) ? CUBE_COLUMN_COUNT - 1 : p2_point.y - 1;
-        }
-        data_p->p2_direction = p2_point;
+        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
+    // 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 (data_p->p1_direction.x == data_p->p2_direction.x &&
+                    if (tron_data_p->direction[player].x == tron_data_p->direction[player2].x &&
-            data_p->p1_direction.y == data_p->p2_direction.y &&
+                            tron_data_p->direction[player].y == tron_data_p->direction[player2].y &&
-            data_p->p1_direction.z == data_p->p2_direction.z) {
+                            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,
-        Cube_Set_Pixel(data_p->p1_direction.z, data_p->p1_direction.x, data_p->p1_direction.y, TRON_COLLISION);
+                                tron_data_p->direction[player].y, TRON_COLLISION);
-        Delay_MS(3000);
+                        // Mark the players as dead
-        Animation_Cube_In_Out(200, TRON_COLLISION);
+                        tron_data_p->dead[player] = 1;
+                        tron_data_p->dead[player2] = 1;
-        Reset_Board(BOARD_MODE_IDLE);
+                        tron_data_p->players_alive -= 2;
+                    }
+                }
+            }
+        }
+    }
     // Check if the location that we are moving to is overlapping either trails
-    uint32_t index, p1_collision = 0, p2_collision = 0;
+    uint8_t index;
-    for (index = 0; index < data_p->length; index++) {
+    for (player = 0; player < tron_data_p->players; player++) {
+        // Check if the player in question is dead
-        if (data_p->p1_direction.x == data_p->p1_body[index].x &&
+        if (tron_data_p->dead[player] == 0) {
-                data_p->p1_direction.y == data_p->p1_body[index].y &&
+            // See if the player's next point hits anyone elses trail
-                data_p->p1_direction.z == data_p->p1_body[index].z) {
+            for (player2 = 0; player2 < tron_data_p->players; player2++) {
-            p1_collision = 1;
+                for (index = 0; index < tron_data_p->length[player2]; index++) {
-        }
-        if (data_p->p1_direction.x == data_p->p2_body[index].x &&
+                    if (tron_data_p->direction[player].x == tron_data_p->body[player2][index].x &&
-                data_p->p1_direction.y == data_p->p2_body[index].y &&
+                            tron_data_p->direction[player].y == tron_data_p->body[player2][index].y &&
-                data_p->p1_direction.z == data_p->p2_body[index].z) {
+                            tron_data_p->direction[player].z == tron_data_p->body[player2][index].z) {
-            p1_collision = 1;
+                        // Indicate the collision point
-        }
-        if (data_p->p2_direction.x == data_p->p2_body[index].x &&
+                        Cube_Set_Pixel(tron_data_p->direction[player].z, tron_data_p->direction[player].x,
-                data_p->p2_direction.y == data_p->p2_body[index].y &&
+                                tron_data_p->direction[player].y, TRON_COLLISION);
-                data_p->p2_direction.z == data_p->p2_body[index].z) {
+                        // Mark the player as dead
-            p2_collision = 1;
+                        tron_data_p->dead[player] = 1;
-        }
-        if (data_p->p2_direction.x == data_p->p1_body[index].x &&
+                        tron_data_p->players_alive -= 1;
-                data_p->p2_direction.y == data_p->p1_body[index].y &&
+                    }
-                data_p->p2_direction.z == data_p->p1_body[index].z) {
+                }
-            p2_collision = 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
-    data_p->length++;
+        if (tron_data_p->dead[player] == 0) {
-    data_p->p1_body[data_p->length - 1] = data_p->p1_direction;
+            tron_data_p->length[player]++;
-    data_p->p2_body[data_p->length - 1] = data_p->p2_direction;
+            tron_data_p->body[player][tron_data_p->length[player] - 1] = tron_data_p->direction[player];
+        }
+    }
-    Cube_Clear();
+    // Update the head to its corresponding color
-    // Draw player 1 light trail
+    for (player = 0; player < tron_data_p->players; player++) {
+        // If player is still alive, recolor its body to indicate its new head
-    for (index = 0; index < data_p->length - 1; index++) {
+        if (tron_data_p->dead[player] == 0) {
+            // Set the color of the new head
-        Cube_Set_Pixel(data_p->p1_body[index].z, data_p->p1_body[index].x, data_p->p1_body[index].y, TRON_PLAYER_1_COLOR);
+            Cube_Set_Pixel(tron_data_p->body[player][tron_data_p->length[player] - 1].z,
-    }
-    Cube_Set_Pixel(data_p->p1_body[data_p->length-1].z, data_p->p1_body[data_p->length-1].x, data_p->p1_body[data_p->length-1].y, TRON_PLAYER_1_HEAD);
+                    tron_data_p->body[player][tron_data_p->length[player] - 1].x,
+                    tron_data_p->body[player][tron_data_p->length[player] - 1].y,
-    // Draw player 2 light trail
+                    tron_data_p->Color_Head_R[player],
-    for (index = 0; index < data_p->length - 1; index++) {
+                    tron_data_p->Color_Head_G[player],
-        Cube_Set_Pixel(data_p->p2_body[index].z, data_p->p2_body[index].x, data_p->p2_body[index].y, TRON_PLAYER_2_COLOR);
+                    tron_data_p->Color_Head_B[player]);
+        }
     }
-    Cube_Set_Pixel(data_p->p2_body[data_p->length-1].z, data_p->p2_body[data_p->length-1].x, data_p->p2_body[data_p->length-1].y, TRON_PLAYER_2_HEAD);
-    // Indicate the point of collision and reset to idle mode
+    // End the game if there is one player left alive
-    if (p1_collision || p2_collision) {
+    if (tron_data_p->players_alive == 1) {
-        uint32_t ind = data_p->length - 1;
+        Delay_MS(5000);
-        if (p1_collision)
+        // Determine which player is still alive and flash his color
-            Cube_Set_Pixel(data_p->p1_body[ind].z, data_p->p1_body[ind].x, data_p->p1_body[ind].y, TRON_COLLISION);
+        for (player = 0; player < tron_data_p->players; player++) {
-        if (p2_collision)
+            if (tron_data_p->dead[player] == 0) {
+                Animation_Cube_In_Out(200, tron_data_p->Color_Head_R[player],
-            Cube_Set_Pixel(data_p->p2_body[ind].z, data_p->p2_body[ind].x, data_p->p2_body[ind].y, TRON_COLLISION);
+                        tron_data_p->Color_Head_G[player], tron_data_p->Color_Head_B[player]);
-        Delay_MS(3000);
+            }
-        if (p1_collision && p2_collision)
+        }
-            Animation_Cube_In_Out(200, TRON_COLLISION);
+        Reset_Board(BOARD_MODE_IDLE);
-        else if (p1_collision)
+    } else if (tron_data_p->players_alive == 0) {
-            Animation_Cube_In_Out(200, TRON_PLAYER_2_HEAD);
+        // If no players are alive flash neutral color
-        else if (p2_collision)
+        Delay_MS(5000);
-            Animation_Cube_In_Out(200, TRON_PLAYER_1_HEAD);
+        Animation_Cube_In_Out(200, TRON_COLLISION_2);
         Reset_Board(BOARD_MODE_IDLE);
+    }
-    // Determine the next direction to take
+    // 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(data_p->p1_last_direction, data_p->p2_last_direction);
+            Tron_Update_Direction(player, (CTRL_BTN_STATUS)tron_data_p->last_direction[player]);
+        }
+    }
     // Decrease the delay between frame updates by 5ms
-    data_p->delay -= 5;
+    tron_data_p->delay -= 5;
+}

Subversion Repositories Code-Repo

(root)/PIC Stuff/Cerebot_32MX7_LED_Cube/TRON.c @ 290 – Rev 276 → 278