mirror of
https://github.com/soconnor0919/eceg431.git
synced 2025-12-11 06:34:43 -05:00
287 lines
8.3 KiB
Plaintext
287 lines
8.3 KiB
Plaintext
// Main game controller for Snake
|
|
// Handles input, game loop, scoring, and game state management
|
|
class SnakeGame {
|
|
field Snake snake;
|
|
field Food food;
|
|
field int score;
|
|
field boolean gameOver;
|
|
field boolean paused;
|
|
field int speed;
|
|
field char lastKey;
|
|
field int pendingDirection;
|
|
field boolean restarting;
|
|
|
|
// create new snake game
|
|
constructor SnakeGame new() {
|
|
let snake = Snake.new();
|
|
let food = Food.new();
|
|
do food.spawn(); // spawn food at random position
|
|
let score = 0;
|
|
let gameOver = false;
|
|
let paused = false;
|
|
let speed = 150; // milliseconds between moves
|
|
let lastKey = 0;
|
|
let pendingDirection = 0;
|
|
let restarting = false;
|
|
|
|
do Random.seed(123); // initialize random generator
|
|
do drawUI();
|
|
return this;
|
|
}
|
|
|
|
// free memory
|
|
method void dispose() {
|
|
do snake.dispose();
|
|
do food.dispose();
|
|
do Memory.deAlloc(this);
|
|
return;
|
|
}
|
|
|
|
// draw game interface elements
|
|
method void drawUI() {
|
|
// draw header area with border only on third row
|
|
do Screen.setColor(true);
|
|
do Screen.drawRectangle(0, 22, 511, 32); // border only on third row
|
|
do Screen.drawRectangle(0, 248, 511, 255); // bottom border
|
|
do Screen.drawRectangle(0, 32, 7, 255); // left border (starts below header)
|
|
do Screen.drawRectangle(504, 32, 511, 255); // right border (starts below header)
|
|
|
|
do showGameTitle();
|
|
do showScore();
|
|
do showControls();
|
|
return;
|
|
}
|
|
|
|
// display game title
|
|
method void showGameTitle() {
|
|
do Output.moveCursor(0, 0);
|
|
do Output.printString("SNAKE GAME");
|
|
return;
|
|
}
|
|
|
|
// display current score
|
|
method void showScore() {
|
|
do Output.moveCursor(1, 0);
|
|
do Output.printString("Score: ");
|
|
do Output.printInt(score);
|
|
return;
|
|
}
|
|
|
|
// display game controls
|
|
method void showControls() {
|
|
do Output.moveCursor(0, 35);
|
|
do Output.printString("Arrows: Move Space: Pause");
|
|
do Output.moveCursor(1, 35);
|
|
do Output.printString("Enter: 2x Speed R: Restart");
|
|
return;
|
|
}
|
|
|
|
// display game over message
|
|
method void showGameOver() {
|
|
// draw larger border box (centered on screen)
|
|
do Screen.setColor(true);
|
|
do Screen.drawRectangle(100, 80, 412, 180); // outer border
|
|
do Screen.setColor(false);
|
|
do Screen.drawRectangle(102, 82, 410, 178); // inner area
|
|
|
|
// properly centered text
|
|
// Box spans columns 12-51 (39 chars wide), center at column 31
|
|
do Output.moveCursor(10, 26); // "GAME OVER!" (10 chars) centered at 31-5=26
|
|
do Output.printString("GAME OVER!");
|
|
do Output.moveCursor(12, 23); // "Final Score: XXX" (~16 chars) centered at 31-8=23
|
|
do Output.printString("Final Score: ");
|
|
do Output.printInt(score);
|
|
do Output.moveCursor(14, 15); // "Press R to restart or Q to quit" (32 chars) at 31-16=15
|
|
do Output.printString("Press R to restart or Q to quit");
|
|
return;
|
|
}
|
|
|
|
// handle user input with key press detection
|
|
method void processInput() {
|
|
var char key;
|
|
let key = Keyboard.keyPressed();
|
|
|
|
// only process if this is a new key press (different from last frame)
|
|
if ((key > 0) & (~(key = lastKey))) {
|
|
if (key = 81) { let gameOver = true; } // q - quit
|
|
if (key = 32) { let paused = ~paused; } // space - pause
|
|
if ((key = 82) & (~restarting)) { // r - restart anytime (prevent rapid calls)
|
|
let restarting = true;
|
|
do restart();
|
|
return;
|
|
}
|
|
if (key = 131) { let pendingDirection = 1; } // up arrow - queue for next frame
|
|
if (key = 133) { let pendingDirection = 2; } // down arrow - queue for next frame
|
|
if (key = 130) { let pendingDirection = 3; } // left arrow - queue for next frame
|
|
if (key = 132) { let pendingDirection = 4; } // right arrow - queue for next frame
|
|
}
|
|
|
|
let lastKey = key;
|
|
return;
|
|
}
|
|
|
|
// get current speed based on whether shift is held
|
|
method int getCurrentSpeed() {
|
|
var char key;
|
|
let key = Keyboard.keyPressed();
|
|
|
|
if (key = 128) { // enter key
|
|
return speed / 2; // 2x speed when enter held
|
|
}
|
|
return speed;
|
|
}
|
|
|
|
// restart the game
|
|
method void restart() {
|
|
do Screen.clearScreen();
|
|
do snake.dispose();
|
|
do food.dispose();
|
|
let snake = Snake.new();
|
|
let food = Food.new();
|
|
do food.spawn();
|
|
let score = 0;
|
|
let gameOver = false;
|
|
let paused = false;
|
|
let speed = 150;
|
|
let lastKey = 0;
|
|
let pendingDirection = 0;
|
|
let restarting = false;
|
|
do drawUI();
|
|
return;
|
|
}
|
|
|
|
// check for input multiple times during wait period
|
|
method void waitWithInput(int milliseconds) {
|
|
var int elapsed;
|
|
var int checkInterval;
|
|
|
|
let elapsed = 0;
|
|
let checkInterval = 20; // check input every 20ms
|
|
|
|
while (elapsed < milliseconds) {
|
|
do processInput();
|
|
if (gameOver) {
|
|
return;
|
|
}
|
|
do Sys.wait(checkInterval);
|
|
let elapsed = elapsed + checkInterval;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// update game state one frame
|
|
method void update() {
|
|
var boolean ateFood;
|
|
var Point nextHead, currentHead;
|
|
var int nextX, nextY, currentDirection;
|
|
|
|
if (paused | gameOver) {
|
|
return;
|
|
}
|
|
|
|
// apply pending direction change at start of frame
|
|
if (pendingDirection > 0) {
|
|
do snake.setDirection(pendingDirection);
|
|
let pendingDirection = 0;
|
|
}
|
|
|
|
// get current head and direction
|
|
let currentHead = snake.getHead();
|
|
let currentDirection = snake.getDirection();
|
|
let nextX = currentHead.getX();
|
|
let nextY = currentHead.getY();
|
|
|
|
// calculate next head position based on direction
|
|
if (currentDirection = 1) { let nextY = nextY - 8; } // up
|
|
if (currentDirection = 2) { let nextY = nextY + 8; } // down
|
|
if (currentDirection = 3) { let nextX = nextX - 8; } // left
|
|
if (currentDirection = 4) { let nextX = nextX + 8; } // right
|
|
|
|
let nextHead = Point.new(nextX, nextY);
|
|
|
|
// check food collision at next position
|
|
let ateFood = food.checkCollision(nextHead);
|
|
do nextHead.dispose();
|
|
|
|
// move snake (with or without growth)
|
|
do snake.move(ateFood);
|
|
|
|
// check collisions after movement
|
|
// check wall collision (adjusted for new header area)
|
|
if (snake.hitWall() | snake.hitSelf()) {
|
|
let gameOver = true;
|
|
return;
|
|
}
|
|
|
|
// handle food consumption
|
|
if (ateFood) {
|
|
let score = score + 10;
|
|
do food.spawn();
|
|
do showScore();
|
|
|
|
// increase speed slightly
|
|
if (speed > 80) {
|
|
let speed = speed - 2;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// wait for game restart input
|
|
method boolean waitForRestart() {
|
|
var char key;
|
|
|
|
while (true) {
|
|
let key = Keyboard.keyPressed();
|
|
if (key = 82) { // r key
|
|
return true;
|
|
}
|
|
if (key = 81) { // q key
|
|
return false;
|
|
}
|
|
do Sys.wait(50);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// main game loop
|
|
method void run() {
|
|
var boolean restart;
|
|
|
|
while (true) {
|
|
// game running loop
|
|
while (~gameOver) {
|
|
do update();
|
|
do waitWithInput(getCurrentSpeed());
|
|
}
|
|
|
|
// game over screen
|
|
do showGameOver();
|
|
let restart = waitForRestart();
|
|
|
|
if (restart) {
|
|
do restart();
|
|
} else {
|
|
return; // quit game
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// get current score
|
|
method int getScore() {
|
|
return score;
|
|
}
|
|
|
|
// check if game is over
|
|
method boolean isGameOver() {
|
|
return gameOver;
|
|
}
|
|
|
|
// check if game is paused
|
|
method boolean isPaused() {
|
|
return paused;
|
|
}
|
|
}
|