| PYTHON = """ |
| import keyboard |
| import random |
| from dataclasses import dataclass |
| |
| |
| class View: |
| def __init__(self, game): |
| self.game = game |
| |
| def render(self): |
| # Print the game state |
| for y in range(10): |
| for x in range(10): |
| if Point(x, y) in self.game.snake: |
| print('S', end='') |
| elif Point(x, y) == self.game.food: |
| print('F', end='') |
| else: |
| print('.', end='') |
| print() |
| print() |
| |
| |
| @dataclass |
| class Point: |
| x: int |
| y: int |
| |
| class Game: |
| def __init__(self): |
| self.snake = [Point(5, 5)] |
| self.food = self.generate_food() |
| self.is_running = True |
| |
| def generate_food(self): |
| return Point(random.randint(0, 10), random.randint(0, 10)) |
| |
| def update(self): |
| # Move the snake |
| self.snake.move() |
| |
| # Check for collision with food |
| if self.snake.head == self.food: |
| self.snake.grow() |
| self.food = self.generate_food() |
| |
| # Check for collision with boundaries |
| if not (0 <= self.snake.head.x < 10 and 0 <= self.snake.head.y < 10): |
| self.is_running = False |
| |
| class Controller: |
| def __init__(self, game, view): |
| self.game = game |
| self.view = view |
| |
| def handle_input(self): |
| if keyboard.is_pressed('up'): |
| self.game.move('up') |
| elif keyboard.is_pressed('down'): |
| self.game.move('down') |
| elif keyboard.is_pressed('left'): |
| self.game.move('left') |
| elif keyboard.is_pressed('right'): |
| self.game.move('right') |
| |
| def main(): |
| game = Game() |
| view = View(game) |
| controller = Controller(game, view) |
| |
| while game.is_running: |
| controller.handle_input() |
| game.update() |
| view.render() |
| |
| if __name__ == "__main__": |
| main() |
| """ |
|
|
|
|
| HTML = """ |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <title>Snake Game</title> |
| <link rel="stylesheet" type="text/css" href="styles.css"> |
| </head> |
| <body> |
| <h1>Snake Game</h1> |
| <canvas id="gameCanvas" width="400" height="400"></canvas> |
| <h2 id="score">Score: 0</h2> |
| <script src="script.js"></script> |
| </body> |
| </html> |
| """ |
|
|
| CSS = """ |
| body { |
| display: flex; |
| justify-content: center; |
| align-items: center; |
| height: 100vh; |
| background-color: #000; |
| color: #fff; |
| font-family: Arial, sans-serif; |
| } |
| |
| #gameCanvas { |
| border: 1px solid #fff; |
| } |
| |
| h1, h2 { |
| text-align: center; |
| } |
| |
| """ |
|
|
| JAVASCRIPT = """ |
| var canvas = document.getElementById('gameCanvas'); |
| var context = canvas.getContext('2d'); |
| |
| var box = 20; |
| var score = 0; |
| var food = null; |
| |
| var snake = []; |
| snake[0] = { x: 10 * box, y: 10 * box }; |
| |
| document.addEventListener('keydown', direction); |
| var d; |
| |
| function direction(event) { |
| if (event.keyCode == 37 && d != "RIGHT") { |
| d = "LEFT"; |
| } else if (event.keyCode == 38 && d != "DOWN") { |
| d = "UP"; |
| } else if (event.keyCode == 39 && d != "LEFT") { |
| d = "RIGHT"; |
| } else if (event.keyCode == 40 && d != "UP") { |
| d = "DOWN"; |
| } |
| } |
| |
| function draw() { |
| context.clearRect(0, 0, canvas.width, canvas.height); |
| for (var i = 0; i < snake.length; i++) { |
| context.fillStyle = (i == 0) ? "green" : "white"; |
| context.fillRect(snake[i].x, snake[i].y, box, box); |
| } |
| |
| if (food == null) { |
| food = { |
| x: Math.floor(Math.random() * 19 + 1) * box, |
| y: Math.floor(Math.random() * 19 + 1) * box |
| } |
| } |
| |
| context.fillStyle = "red"; |
| context.fillRect(food.x, food.y, box, box); |
| |
| var snakeX = snake[0].x; |
| var snakeY = snake[0].y; |
| |
| if (d == "LEFT") snakeX -= box; |
| if (d == "UP") snakeY -= box; |
| if (d == "RIGHT") snakeX += box; |
| if (d == "DOWN") snakeY += box; |
| |
| if (snakeX == food.x && snakeY == food.y) { |
| score++; |
| food = null; |
| } else { |
| snake.pop(); |
| } |
| |
| var newHead = { |
| x: snakeX, |
| y: snakeY |
| } |
| |
| if (snakeX < 0 || snakeY < 0 || snakeX > 19 * box || snakeY > 19 * box || collision(newHead, snake)) { |
| clearInterval(game); |
| } |
| |
| snake.unshift(newHead); |
| |
| document.getElementById('score').innerHTML = "Score: " + score; |
| } |
| |
| function collision(head, array) { |
| for (var i = 0; i < array.length; i++) { |
| if (head.x == array[i].x && head.y == array[i].y) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| var game = setInterval(draw, 100); |
| """ |
|
|
| JAVA = """ |
| import java.awt.Color; |
| import java.awt.Dimension; |
| import java.awt.Font; |
| import java.awt.FontMetrics; |
| import java.awt.Graphics; |
| import java.awt.Image; |
| import java.awt.Toolkit; |
| import java.awt.event.ActionEvent; |
| import java.awt.event.ActionListener; |
| import java.awt.event.KeyAdapter; |
| import java.awt.event.KeyEvent; |
| import javax.swing.ImageIcon; |
| import javax.swing.JPanel; |
| import javax.swing.Timer; |
| |
| public class SnakeGame extends JPanel implements ActionListener { |
| |
| private final int B_WIDTH = 300; |
| private final int B_HEIGHT = 300; |
| private final int DOT_SIZE = 10; |
| private final int ALL_DOTS = 900; |
| private final int RAND_POS = 29; |
| private final int DELAY = 140; |
| |
| private final int x[] = new int[ALL_DOTS]; |
| private final int y[] = new int[ALL_DOTS]; |
| |
| private int dots; |
| private int apple_x; |
| private int apple_y; |
| |
| private boolean leftDirection = false; |
| private boolean rightDirection = true; |
| private boolean upDirection = false; |
| private boolean downDirection = false; |
| private boolean inGame = true; |
| |
| private Timer timer; |
| private Image ball; |
| private Image apple; |
| private Image head; |
| |
| public SnakeGame() { |
| |
| initBoard(); |
| } |
| |
| private void initBoard() { |
| |
| addKeyListener(new TAdapter()); |
| setBackground(Color.black); |
| setFocusable(true); |
| |
| setPreferredSize(new Dimension(B_WIDTH, B_HEIGHT)); |
| loadImages(); |
| initGame(); |
| } |
| |
| private void loadImages() { |
| |
| ImageIcon iid = new ImageIcon("src/resources/dot.png"); |
| ball = iid.getImage(); |
| |
| ImageIcon iia = new ImageIcon("src/resources/apple.png"); |
| apple = iia.getImage(); |
| |
| ImageIcon iih = new ImageIcon("src/resources/head.png"); |
| head = iih.getImage(); |
| } |
| |
| private void initGame() { |
| |
| dots = 3; |
| |
| for (int z = 0; z < dots; z++) { |
| x[z] = 50 - z * 10; |
| y[z] = 50; |
| } |
| |
| locateApple(); |
| |
| timer = new Timer(DELAY, this); |
| timer.start(); |
| } |
| |
| @Override |
| public void paintComponent(Graphics g) { |
| super.paintComponent(g); |
| |
| doDrawing(g); |
| } |
| |
| private void doDrawing(Graphics g) { |
| |
| if (inGame) { |
| |
| g.drawImage(apple, apple_x, apple_y, this); |
| |
| for (int z = 0; z < dots; z++) { |
| if (z == 0) { |
| g.drawImage(head, x[z], y[z], this); |
| } else { |
| g.drawImage(ball, x[z], y[z], this); |
| } |
| } |
| |
| Toolkit.getDefaultToolkit().sync(); |
| |
| } else { |
| |
| gameOver(g); |
| } |
| } |
| |
| private void gameOver(Graphics g) { |
| |
| String msg = "Game Over"; |
| Font small = new Font("Helvetica", Font.BOLD, 14); |
| FontMetrics metr = getFontMetrics(small); |
| |
| g.setColor(Color.white); |
| g.setFont(small); |
| g.drawString(msg, (B_WIDTH - metr.stringWidth(msg)) / 2, B_HEIGHT / 2); |
| } |
| |
| private void checkApple() { |
| |
| if ((x[0] == apple_x) && (y[0] == apple_y)) { |
| |
| dots++; |
| locateApple(); |
| } |
| } |
| |
| private void move() { |
| |
| for (int z = dots; z > 0; z--) { |
| x[z] = x[(z - 1)]; |
| y[z] = y[(z - 1)]; |
| } |
| |
| if (leftDirection) { |
| x[0] -= DOT_SIZE; |
| } |
| |
| if (rightDirection) { |
| x[0] += DOT_SIZE; |
| } |
| |
| if (upDirection) { |
| y[0] -= DOT_SIZE; |
| } |
| |
| if (downDirection) { |
| y[0] += DOT_SIZE; |
| } |
| } |
| |
| private void checkCollision() { |
| |
| for (int z = dots; z > 0; z--) { |
| |
| if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z])) { |
| inGame = false; |
| } |
| } |
| |
| if (y[0] >= B_HEIGHT) { |
| inGame = false; |
| } |
| |
| if (y[0] < 0) { |
| inGame = false; |
| } |
| |
| if (x[0] >= B_WIDTH) { |
| inGame = false; |
| } |
| |
| if (x[0] < 0) { |
| inGame = false; |
| } |
| |
| if (!inGame) { |
| timer.stop(); |
| } |
| } |
| |
| private void locateApple() { |
| |
| int r = (int) (Math.random() * RAND_POS); |
| apple_x = ((r * DOT_SIZE)); |
| |
| r = (int) (Math.random() * RAND_POS); |
| apple_y = ((r * DOT_SIZE)); |
| } |
| |
| @Override |
| public void actionPerformed(ActionEvent e) { |
| |
| if (inGame) { |
| |
| checkApple(); |
| checkCollision(); |
| move(); |
| } |
| |
| repaint(); |
| } |
| |
| private class TAdapter extends KeyAdapter { |
| |
| @Override |
| public void keyPressed(KeyEvent e) { |
| |
| int key = e.getKeyCode(); |
| |
| if ((key == KeyEvent.VK_LEFT) && (!rightDirection)) { |
| leftDirection = true; |
| upDirection = false; |
| downDirection = false; |
| } |
| |
| if ((key == KeyEvent.VK_RIGHT) && (!leftDirection)) { |
| rightDirection = true; |
| upDirection = false; |
| downDirection = false; |
| } |
| |
| if ((key == KeyEvent.VK_UP) && (!downDirection)) { |
| upDirection = true; |
| rightDirection = false; |
| leftDirection = false; |
| } |
| |
| if ((key == KeyEvent.VK_DOWN) && (!upDirection)) { |
| downDirection = true; |
| rightDirection = false; |
| leftDirection = false; |
| } |
| } |
| } |
| } |
| """ |
|
|
| C_SHARP = """ |
| using System; |
| using System.Collections.Generic; |
| using System.Linq; |
| using System.Threading; |
| using System.Threading.Tasks; |
| |
| namespace SnakeGame |
| { |
| // Model |
| public class Game |
| { |
| public Snake Snake { get; set; } |
| public Point Food { get; set; } |
| public int Score { get; set; } |
| public bool Over { get; set; } |
| |
| public Game() |
| { |
| Snake = new Snake(); |
| Food = new Point(); |
| Score = 0; |
| Over = false; |
| } |
| } |
| |
| public class Snake |
| { |
| public Queue<Point> Body { get; set; } |
| public Direction Direction { get; set; } |
| |
| public Snake() |
| { |
| Body = new Queue<Point>(); |
| Direction = Direction.Right; |
| } |
| } |
| |
| public class Point |
| { |
| public int X { get; set; } |
| public int Y { get; set; } |
| } |
| |
| public enum Direction |
| { |
| Up, |
| Down, |
| Left, |
| Right |
| } |
| |
| // View |
| public class GameView |
| { |
| public void Draw(Game game) |
| { |
| Console.Clear(); |
| foreach (var point in game.Snake.Body) |
| { |
| Console.SetCursorPosition(point.X, point.Y); |
| Console.Write("O"); |
| } |
| Console.SetCursorPosition(game.Food.X, game.Food.Y); |
| Console.Write("F"); |
| Console.SetCursorPosition(0, 0); |
| Console.Write("Score: " + game.Score); |
| } |
| } |
| |
| // Controller |
| public class GameController |
| { |
| private Game game; |
| private GameView view; |
| |
| public GameController(Game game, GameView view) |
| { |
| this.game = game; |
| this.view = view; |
| } |
| |
| public void Start() |
| { |
| while (!game.Over) |
| { |
| Thread.Sleep(100); |
| MoveSnake(); |
| CheckCollision(); |
| view.Draw(game); |
| } |
| } |
| |
| private void MoveSnake() |
| { |
| var head = game.Snake.Body.Last(); |
| var newHead = new Point { X = head.X, Y = head.Y }; |
| switch (game.Snake.Direction) |
| { |
| case Direction.Up: |
| newHead.Y--; |
| break; |
| case Direction.Down: |
| newHead.Y++; |
| break; |
| case Direction.Left: |
| newHead.X--; |
| break; |
| case Direction.Right: |
| newHead.X++; |
| break; |
| } |
| game.Snake.Body.Enqueue(newHead); |
| if (newHead.X == game.Food.X && newHead.Y == game.Food.Y) |
| { |
| game.Score++; |
| game.Food = new Point { X = new Random().Next(1, 10), Y = new Random().Next(1, 10) }; |
| } |
| else |
| { |
| game.Snake.Body.Dequeue(); |
| } |
| } |
| |
| private void CheckCollision() |
| { |
| var head = game.Snake.Body.Last(); |
| if (head.X < 0 || head.Y < 0 || head.X >= 10 || head.Y >= 10) |
| { |
| game.Over = true; |
| } |
| if (game.Snake.Body.Take(game.Snake.Body.Count - 1).Any(p => p.X == head.X && p.Y == head.Y)) |
| { |
| game.Over = true; |
| } |
| } |
| } |
| |
| class Program |
| { |
| static void Main(string[] args) |
| { |
| var game = new Game(); |
| var view = new GameView(); |
| var controller = new GameController(game, view); |
| controller.Start(); |
| } |
| } |
| } |
| """ |
|
|
| TYPESCRIPT = """ |
| // Importing necessary modules |
| import { Application, Graphics, Keyboard } from 'pixi.js'; |
| |
| // Defining the Model class |
| class Model { |
| // The snake's body is represented as an array of points |
| body: Array<{x: number, y: number}>; |
| |
| constructor() { |
| this.body = [{x: 0, y: 0}]; |
| } |
| |
| // Method to move the snake |
| move(direction: {x: number, y: number}) { |
| // Add a new head in the direction of movement |
| this.body.unshift({ |
| x: this.body[0].x + direction.x, |
| y: this.body[0].y + direction.y |
| }); |
| |
| // Remove the tail |
| this.body.pop(); |
| } |
| } |
| |
| // Defining the View class |
| class View { |
| // The view needs a reference to the model and the PIXI application |
| model: Model; |
| app: Application; |
| graphics: Graphics; |
| |
| constructor(model: Model, app: Application) { |
| this.model = model; |
| this.app = app; |
| this.graphics = new Graphics(); |
| this.app.stage.addChild(this.graphics); |
| } |
| |
| // Method to render the snake |
| render() { |
| // Clear the previous frame |
| this.graphics.clear(); |
| |
| // Draw each part of the snake's body |
| for (let part of this.model.body) { |
| this.graphics.beginFill(0xFFFFFF); |
| this.graphics.drawRect(part.x * 10, part.y * 10, 10, 10); |
| this.graphics.endFill(); |
| } |
| } |
| } |
| |
| // Defining the Controller class |
| class Controller { |
| // The controller needs a reference to the model and the view |
| model: Model; |
| view: View; |
| direction: {x: number, y: number}; |
| |
| constructor(model: Model, view: View) { |
| this.model = model; |
| this.view = view; |
| this.direction = {x: 1, y: 0}; |
| |
| // Set up keyboard controls |
| window.addEventListener('keydown', (e) => this.handleKeydown(e)); |
| } |
| |
| // Method to handle keyboard input |
| handleKeydown(event: KeyboardEvent) { |
| switch (event.key) { |
| case 'ArrowUp': |
| this.direction = {x: 0, y: -1}; |
| break; |
| case 'ArrowDown': |
| this.direction = {x: 0, y: 1}; |
| break; |
| case 'ArrowLeft': |
| this.direction = {x: -1, y: 0}; |
| break; |
| case 'ArrowRight': |
| this.direction = {x: 1, y: 0}; |
| break; |
| } |
| } |
| |
| // Method to update the game state |
| update() { |
| this.model.move(this.direction); |
| this.view.render(); |
| } |
| } |
| |
| // Create the PIXI application |
| let app = new Application({width: 800, height: 600}); |
| |
| // Create the MVC components |
| let model = new Model(); |
| let view = new View(model, app); |
| let controller = new Controller(model, view); |
| |
| // Start the game loop |
| setInterval(() => controller.update(), 100); |
| """ |
|
|
| RUBY = """ |
| require 'io/console' |
| |
| # Model |
| class Game |
| attr_accessor :score, :snake, :food |
| |
| def initialize |
| @score = 0 |
| @snake = [[2, 2]] |
| @food = [6, 4] |
| end |
| |
| def move(direction) |
| head = @snake.first.dup |
| case direction |
| when 'up' |
| head[0] -= 1 |
| when 'down' |
| head[0] += 1 |
| when 'left' |
| head[1] -= 1 |
| when 'right' |
| head[1] += 1 |
| end |
| @snake.unshift(head) |
| |
| if @snake.first == @food |
| @score += 1 |
| @food = [rand(1..8), rand(1..8)] |
| else |
| @snake.pop |
| end |
| end |
| |
| def game_over? |
| head = @snake.first |
| @snake[1..-1].include?(head) || head[0] == 0 || head[1] == 0 || head[0] == 9 || head[1] == 9 |
| end |
| end |
| |
| # View |
| class View |
| def render(game) |
| system('clear') |
| puts "Score: #{game.score}" |
| (0..9).each do |i| |
| (0..9).each do |j| |
| if game.snake.include?([i, j]) |
| print 'S' |
| elsif game.food == [i, j] |
| print 'F' |
| else |
| print '.' |
| end |
| end |
| puts |
| end |
| end |
| end |
| |
| # Controller |
| class Controller |
| def initialize |
| @game = Game.new |
| @view = View.new |
| @direction = 'right' |
| end |
| |
| def play |
| loop do |
| @view.render(@game) |
| break if @game.game_over? |
| |
| input = IO.console.getch |
| case input |
| when 'w' |
| @direction = 'up' |
| when 's' |
| @direction = 'down' |
| when 'a' |
| @direction = 'left' |
| when 'd' |
| @direction = 'right' |
| end |
| @game.move(@direction) |
| end |
| puts "Game Over! Your score was #{@game.score}." |
| end |
| end |
| |
| Controller.new.play |
| |
| """ |
|
|
| PHP = """ |
| <?php |
| // Model |
| class Snake { |
| public $body; |
| public $direction; |
| |
| public function __construct() { |
| $this->body = array(array(2, 0), array(1, 0), array(0, 0)); |
| $this->direction = 'right'; |
| } |
| |
| public function move() { |
| $head = current($this->body); |
| switch($this->direction) { |
| case 'right': |
| $this->body[] = array($head[0] + 1, $head[1]); |
| break; |
| case 'left': |
| $this->body[] = array($head[0] - 1, $head[1]); |
| break; |
| case 'up': |
| $this->body[] = array($head[0], $head[1] - 1); |
| break; |
| case 'down': |
| $this->body[] = array($head[0], $head[1] + 1); |
| break; |
| } |
| array_shift($this->body); |
| } |
| |
| public function changeDirection($new_direction) { |
| $this->direction = $new_direction; |
| } |
| } |
| |
| // View |
| class GameView { |
| public function render($snake) { |
| $output = ''; |
| for ($y=0; $y<20; $y++) { |
| for ($x=0; $x<20; $x++) { |
| if (in_array(array($x, $y), $snake->body)) { |
| $output .= 'X'; |
| } else { |
| $output .= ' '; |
| } |
| } |
| $output .= "\n"; |
| } |
| echo $output; |
| } |
| } |
| |
| // Controller |
| class GameController { |
| public $snake; |
| public $view; |
| |
| public function __construct() { |
| $this->snake = new Snake(); |
| $this->view = new GameView(); |
| } |
| |
| public function start() { |
| while (true) { |
| $this->view->render($this->snake); |
| $this->snake->move(); |
| sleep(1); |
| } |
| } |
| |
| public function changeDirection($new_direction) { |
| $this->snake->changeDirection($new_direction); |
| } |
| } |
| |
| // Game loop |
| $game = new GameController(); |
| $game->start(); |
| ?> |
| """ |
|
|
| SWIFT = """ |
| import Foundation |
| import Cocoa |
| |
| // MARK: - Model |
| struct Point { |
| var x: Int |
| var y: Int |
| } |
| |
| class Snake { |
| var body: [Point] |
| var direction: Direction |
| |
| init(startPoint: Point) { |
| body = [startPoint] |
| direction = .right |
| } |
| |
| func move() { |
| let head = body.first! |
| var newHead = head |
| |
| switch direction { |
| case .up: |
| newHead.y += 1 |
| case .down: |
| newHead.y -= 1 |
| case .left: |
| newHead.x -= 1 |
| case .right: |
| newHead.x += 1 |
| } |
| |
| body.insert(newHead, at: 0) |
| body.removeLast() |
| } |
| |
| func grow() { |
| let tail = body.last! |
| body.append(tail) |
| } |
| } |
| |
| enum Direction { |
| case up |
| case down |
| case left |
| case right |
| } |
| |
| // MARK: - View |
| class GameView { |
| func draw(snake: Snake) { |
| for point in snake.body { |
| print("O", terminator: "") |
| } |
| print("\n") |
| } |
| } |
| |
| // MARK: - Controller |
| class GameController { |
| var snake: Snake |
| var view: GameView |
| |
| init() { |
| snake = Snake(startPoint: Point(x: 0, y: 0)) |
| view = GameView() |
| } |
| |
| func start() { |
| while true { |
| snake.move() |
| view.draw(snake: snake) |
| sleep(1) |
| } |
| } |
| |
| func handleKey(key: String) { |
| switch key { |
| case "w": |
| snake.direction = .up |
| case "s": |
| snake.direction = .down |
| case "a": |
| snake.direction = .left |
| case "d": |
| snake.direction = .right |
| default: |
| break |
| } |
| } |
| } |
| |
| // MARK: - Main |
| let gameController = GameController() |
| gameController.start() |
| """ |
|
|
| GO = """ |
| package main |
| |
| import ( |
| "fmt" |
| "os" |
| "os/exec" |
| "time" |
| "math/rand" |
| "bufio" |
| "syscall" |
| "unsafe" |
| ) |
| |
| // Model |
| type Point struct { |
| X int |
| Y int |
| } |
| |
| type Snake struct { |
| Body []Point |
| Dir string |
| } |
| |
| type Game struct { |
| Snake Snake |
| Food Point |
| Score int |
| Width int |
| Height int |
| } |
| |
| // View |
| func (game *Game) Render() { |
| clearScreen() |
| for y := 0; y < game.Height; y++ { |
| for x := 0; x < game.Width; x++ { |
| point := Point{X: x, Y: y} |
| switch { |
| case point == game.Food: |
| fmt.Print("F") |
| case game.Snake.Contains(point): |
| fmt.Print("S") |
| default: |
| fmt.Print(" ") |
| } |
| } |
| fmt.Println() |
| } |
| fmt.Println("Score:", game.Score) |
| } |
| |
| // Controller |
| func (game *Game) Update() { |
| head := game.Snake.Body[0] |
| switch game.Snake.Dir { |
| case "up": |
| head.Y-- |
| case "down": |
| head.Y++ |
| case "left": |
| head.X-- |
| case "right": |
| head.X++ |
| } |
| |
| if head.X < 0 || head.Y < 0 || head.X >= game.Width || head.Y >= game.Height { |
| game.Score = -1 |
| return |
| } |
| |
| if game.Snake.Contains(head) { |
| game.Score = -1 |
| return |
| } |
| |
| if head == game.Food { |
| game.Score++ |
| game.Food = Point{rand.Intn(game.Width), rand.Intn(game.Height)} |
| } else { |
| game.Snake.Body = game.Snake.Body[:len(game.Snake.Body)-1] |
| } |
| |
| game.Snake.Body = append([]Point{head}, game.Snake.Body...) |
| } |
| |
| func (snake *Snake) Contains(point Point) bool { |
| for _, bodyPoint := range snake.Body { |
| if bodyPoint == point { |
| return true |
| } |
| } |
| return false |
| } |
| |
| func clearScreen() { |
| cmd := exec.Command("clear") |
| cmd.Stdout = os.Stdout |
| cmd.Run() |
| } |
| |
| func main() { |
| game := &Game{ |
| Snake: Snake{ |
| Body: []Point{{10, 10}}, |
| Dir: "right", |
| }, |
| Food: Point{15, 15}, |
| Score: 0, |
| Width: 20, |
| Height: 20, |
| } |
| |
| go func() { |
| reader := bufio.NewReader(os.Stdin) |
| for { |
| char, _, err := reader.ReadRune() |
| if err != nil { |
| panic(err) |
| } |
| |
| switch char { |
| case 'w': |
| game.Snake.Dir = "up" |
| case 's': |
| game.Snake.Dir = "down" |
| case 'a': |
| game.Snake.Dir = "left" |
| case 'd': |
| game.Snake.Dir = "right" |
| } |
| } |
| }() |
| |
| for game.Score >= 0 { |
| game.Render() |
| time.Sleep(time.Second / 5) |
| game.Update() |
| } |
| } |
| """ |
|
|
| KOTLIN = """ |
| import java.awt.Color |
| import java.awt.Dimension |
| import java.awt.Font |
| import java.awt.FontMetrics |
| import java.awt.Graphics |
| import java.awt.Image |
| import java.awt.Toolkit |
| import java.awt.event.ActionEvent |
| import java.awt.event.ActionListener |
| import java.awt.event.KeyAdapter |
| import java.awt.event.KeyEvent |
| import javax.swing.ImageIcon |
| import javax.swing.JPanel |
| import javax.swing.Timer |
| |
| class Board : JPanel(), ActionListener { |
| |
| private val B_WIDTH = 300 |
| private val B_HEIGHT = 300 |
| private val DOT_SIZE = 10 |
| private val ALL_DOTS = 900 |
| private val RAND_POS = 29 |
| private val DELAY = 140 |
| |
| private val x = IntArray(ALL_DOTS) |
| private val y = IntArray(ALL_DOTS) |
| |
| private var dots: Int = 0 |
| private var apple_x: Int = 0 |
| private var apple_y: Int = 0 |
| |
| private var leftDirection = false |
| private var rightDirection = true |
| private var upDirection = false |
| private var downDirection = false |
| private var inGame = true |
| |
| private lateinit var timer: Timer |
| private lateinit var apple: Image |
| private lateinit var dot: Image |
| private lateinit var head: Image |
| |
| init { |
| initBoard() |
| } |
| |
| private fun initBoard() { |
| |
| addKeyListener(TAdapter()) |
| background = Color.black |
| isFocusable = true |
| |
| preferredSize = Dimension(B_WIDTH, B_HEIGHT) |
| loadImages() |
| initGame() |
| } |
| |
| private fun loadImages() { |
| |
| val iid = ImageIcon("src/resources/apple.png") |
| apple = iid.image |
| |
| val iid2 = ImageIcon("src/resources/dot.png") |
| dot = iid2.image |
| |
| val iid3 = ImageIcon("src/resources/head.png") |
| head = iid3.image |
| } |
| |
| private fun initGame() { |
| |
| dots = 3 |
| |
| for (z in 0 until dots) { |
| x[z] = 50 - z * 10 |
| y[z] = 50 |
| } |
| |
| locateApple() |
| |
| timer = Timer(DELAY, this) |
| timer.start() |
| } |
| |
| override fun paintComponent(g: Graphics) { |
| super.paintComponent(g) |
| |
| doDrawing(g) |
| } |
| |
| private fun doDrawing(g: Graphics) { |
| |
| if (inGame) { |
| |
| g.drawImage(apple, apple_x, apple_y, this) |
| |
| for (z in 0 until dots) { |
| if (z == 0) { |
| g.drawImage(head, x[z], y[z], this) |
| } else { |
| g.drawImage(dot, x[z], y[z], this) |
| } |
| } |
| |
| Toolkit.getDefaultToolkit().sync() |
| |
| } else { |
| |
| gameOver(g) |
| } |
| } |
| |
| private fun gameOver(g: Graphics) { |
| |
| val msg = "Game Over" |
| val font = Font("Helvetica", Font.BOLD, 14) |
| val metrics: FontMetrics = this.getFontMetrics(font) |
| |
| g.color = Color.white |
| g.font = font |
| g.drawString(msg, (B_WIDTH - metrics.stringWidth(msg)) / 2, B_HEIGHT / 2) |
| } |
| |
| private fun checkApple() { |
| |
| if (x[0] == apple_x && y[0] == apple_y) { |
| |
| dots++ |
| locateApple() |
| } |
| } |
| |
| private fun move() { |
| |
| for (z in dots downTo 1) { |
| x[z] = x[z - 1] |
| y[z] = y[z - 1] |
| } |
| |
| if (leftDirection) { |
| x[0] -= DOT_SIZE |
| } |
| |
| if (rightDirection) { |
| x[0] += DOT_SIZE |
| } |
| |
| if (upDirection) { |
| y[0] -= DOT_SIZE |
| } |
| |
| if (downDirection) { |
| y[0] += DOT_SIZE |
| } |
| } |
| |
| private fun checkCollision() { |
| |
| for (z in dots downTo 1) { |
| if (z > 4 && x[0] == x[z] && y[0] == y[z]) { |
| inGame = false |
| } |
| } |
| |
| if (y[0] >= B_HEIGHT) { |
| inGame = false |
| } |
| |
| if (y[0] < 0) { |
| inGame = false |
| } |
| |
| if (x[0] >= B_WIDTH) { |
| inGame = false |
| } |
| |
| if (x[0] < 0) { |
| inGame = false |
| } |
| |
| if (!inGame) { |
| timer.stop() |
| } |
| } |
| |
| private fun locateApple() { |
| |
| val r = (Math.random() * RAND_POS).toInt() |
| apple_x = r * DOT_SIZE |
| |
| r = (Math.random() * RAND_POS).toInt() |
| apple_y = r * DOT_SIZE |
| } |
| |
| override fun actionPerformed(e: ActionEvent) { |
| |
| if (inGame) { |
| |
| checkApple() |
| checkCollision() |
| move() |
| } |
| |
| repaint() |
| } |
| |
| private inner class TAdapter : KeyAdapter() { |
| |
| override fun keyPressed(e: KeyEvent) { |
| |
| val key = e.keyCode |
| |
| if (key == KeyEvent.VK_LEFT && !rightDirection) { |
| leftDirection = true |
| upDirection = false |
| downDirection = false |
| } |
| |
| if (key == KeyEvent.VK_RIGHT && !leftDirection) { |
| rightDirection = true |
| upDirection = false |
| downDirection = false |
| } |
| |
| if (key == KeyEvent.VK_UP && !downDirection) { |
| upDirection = true |
| rightDirection = false |
| leftDirection = false |
| } |
| |
| if (key == KeyEvent.VK_DOWN && !upDirection) { |
| downDirection = true |
| rightDirection = false |
| leftDirection = false |
| } |
| } |
| } |
| } |
| """ |
| RUST = """ |
| extern crate termion; |
| |
| use std::io; |
| use std::io::stdout; |
| use std::io::Write; |
| use std::thread; |
| use std::time::Duration; |
| use termion::raw::IntoRawMode; |
| use termion::input::TermRead; |
| use termion::event::Key; |
| |
| // Define the size of the game board |
| const BOARD_SIZE: usize = 10; |
| |
| // Define the game state |
| struct GameState { |
| snake: Snake, |
| food: Food, |
| } |
| |
| // Define the snake |
| struct Snake { |
| body: Vec<(usize, usize)>, |
| direction: Direction, |
| } |
| |
| // Define the food |
| struct Food { |
| position: (usize, usize), |
| } |
| |
| // Define the possible directions the snake can move |
| enum Direction { |
| Up, |
| Down, |
| Left, |
| Right, |
| } |
| |
| // Implement the game state |
| impl GameState { |
| fn new() -> GameState { |
| GameState { |
| snake: Snake::new(), |
| food: Food::new(), |
| } |
| } |
| |
| // Update the game state |
| fn update(&mut self) { |
| self.snake.move(); |
| if self.snake.eats(&self.food) { |
| self.food = Food::new(); |
| } |
| } |
| } |
| |
| // Implement the snake |
| impl Snake { |
| fn new() -> Snake { |
| Snake { |
| body: vec![(BOARD_SIZE / 2, BOARD_SIZE / 2)], |
| direction: Direction::Right, |
| } |
| } |
| |
| // Move the snake in the current direction |
| fn move(&mut self) { |
| let (head_x, head_y) = self.body[0]; |
| match self.direction { |
| Direction::Up => self.body.insert(0, (head_x, head_y - 1)), |
| Direction::Down => self.body.insert(0, (head_x, head_y + 1)), |
| Direction::Left => self.body.insert(0, (head_x - 1, head_y)), |
| Direction::Right => self.body.insert(0, (head_x + 1, head_y)), |
| } |
| self.body.pop(); |
| } |
| |
| // Check if the snake eats the food |
| fn eats(&self, food: &Food) -> bool { |
| self.body[0] == food.position |
| } |
| } |
| |
| // Implement the food |
| impl Food { |
| fn new() -> Food { |
| Food { |
| position: (rand::random::<usize>() % BOARD_SIZE, rand::random::<usize>() % BOARD_SIZE), |
| } |
| } |
| } |
| |
| // Implement the view |
| fn render(game_state: &GameState) { |
| for y in 0..BOARD_SIZE { |
| for x in 0..BOARD_SIZE { |
| if game_state.snake.body.contains(&(x, y)) { |
| print!("S"); |
| } else if game_state.food.position == (x, y) { |
| print!("F"); |
| } else { |
| print!(" "); |
| } |
| } |
| println!(); |
| } |
| } |
| |
| // Implement the controller |
| fn controller(game_state: &mut GameState) { |
| let stdin = io::stdin(); |
| for c in stdin.keys() { |
| match c.unwrap() { |
| Key::Char('q') => break, |
| Key::Up => game_state.snake.direction = Direction::Up, |
| Key::Down => game_state.snake.direction = Direction::Down, |
| Key::Left => game_state.snake.direction = Direction::Left, |
| Key::Right => game_state.snake.direction = Direction::Right, |
| _ => {} |
| } |
| } |
| } |
| |
| fn main() { |
| let mut game_state = GameState::new(); |
| let mut stdout = stdout().into_raw_mode().unwrap(); |
| |
| loop { |
| write!(stdout, "{}", termion::clear::All).unwrap(); |
| render(&game_state); |
| stdout.flush().unwrap(); |
| game_state.update(); |
| thread::sleep(Duration::from_millis(1000)); |
| } |
| } |
| """ |
|
|
| C_PLUS_PLUS = """ |
| #include <iostream> |
| #include <conio.h> |
| #include <windows.h> |
| using namespace std; |
| |
| bool gameOver; |
| const int width = 20; |
| const int height = 20; |
| int x, y, fruitX, fruitY, score; |
| int tailX[100], tailY[100]; |
| int nTail; |
| enum eDirecton { STOP = 0, LEFT, RIGHT, UP, DOWN}; |
| eDirecton dir; |
| |
| void Setup() |
| { |
| gameOver = false; |
| dir = STOP; |
| x = width / 2; |
| y = height / 2; |
| fruitX = rand() % width; |
| fruitY = rand() % height; |
| score = 0; |
| } |
| void Draw() |
| { |
| system("cls"); |
| for (int i = 0; i < width+2; i++) |
| cout << "#"; |
| cout << endl; |
| |
| for (int i = 0; i < height; i++) |
| { |
| for (int j = 0; j < width; j++) |
| { |
| if (j == 0) |
| cout << "#"; |
| if (i == y && j == x) |
| cout << "*"; |
| else if (i == fruitY && j == fruitX) |
| cout << "%"; |
| else |
| { |
| |
| bool print = false; |
| for (int k = 0; k < nTail ; k++) |
| { |
| if (tailX[k] == j && tailY[k] == i) |
| { |
| cout << "*"; print = true; |
| } |
| } |
| if (!print) |
| cout << " "; |
| |
| } |
| |
| if (j == width - 1) |
| cout << "#"; |
| } |
| cout << endl; |
| } |
| |
| for (int i = 0; i < width+2; i++) |
| cout << "#"; |
| cout << endl; |
| cout << "Score:" << score << endl; |
| |
| } |
| |
| void Input() |
| { |
| if (_kbhit()) |
| { |
| switch (_getch()) |
| { |
| case 'a': |
| dir = LEFT; |
| break; |
| case 'd': |
| dir = RIGHT; |
| break; |
| case 'w': |
| dir = UP; |
| break; |
| case 's': |
| dir = DOWN; |
| break; |
| case 'x': |
| gameOver = true; |
| break; |
| } |
| } |
| } |
| |
| void algorithm() |
| { |
| int prevX = tailX[0]; |
| int prevY = tailY[0]; |
| int prev2X, prev2Y; |
| tailX[0] = x; |
| tailY[0] = y; |
| |
| for(int i = 1; i < nTail ; i++) |
| { |
| prev2X = tailX[i]; |
| prev2Y = tailY[i]; |
| tailX[i] = prevX; |
| tailY[i] = prevY; |
| prevX = prev2X; |
| prevY = prev2Y; |
| } |
| |
| switch (dir) |
| { |
| case LEFT: |
| x--; |
| break; |
| case RIGHT: |
| x++; |
| break; |
| case UP: |
| y--; |
| break; |
| case DOWN: |
| y++; |
| break; |
| default: |
| break; |
| } |
| if (x >= width) |
| x = 0; else if (x < 0) x = width - 1; |
| if (y >= height) |
| y = 0; else if (y < 0) y = height - 1; |
| |
| for (int i = 0; i < nTail ; i++) |
| if (tailX[i] == x && tailY[i] == y) |
| gameOver = true; |
| |
| if (x == fruitX && y == fruitY) |
| { |
| score += 10; |
| fruitX = rand() % width; |
| fruitY = rand() % height; |
| nTail++; |
| } |
| } |
| |
| int main() |
| { |
| Setup(); |
| while (!gameOver) |
| { |
| Draw(); |
| Input(); |
| algorithm(); |
| } |
| return 0; |
| } |
| """ |
|
|
| C = """ |
| #include <stdio.h> |
| #include <conio.h> |
| #include <windows.h> |
| #include <stdlib.h> |
| |
| #define WIDTH 20 |
| #define HEIGHT 20 |
| #define MAX_SNAKE_SIZE WIDTH *HEIGHT |
| |
| // Model |
| typedef struct { |
| int x, y; |
| } Point; |
| |
| typedef struct { |
| Point body[MAX_SNAKE_SIZE]; |
| int size; |
| Point direction; |
| } Snake; |
| |
| typedef struct { |
| Point position; |
| int isEaten; |
| } Fruit; |
| |
| // View |
| void gotoxy(int x, int y) { |
| COORD coord; |
| coord.X = x; |
| coord.Y = y; |
| SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); |
| } |
| |
| void drawBoard() { |
| int i; |
| for (i = 0; i < WIDTH + 2; i++) { |
| gotoxy(i, 0); |
| printf("#"); |
| gotoxy(i, HEIGHT + 1); |
| printf("#"); |
| } |
| for (i = 0; i < HEIGHT + 2; i++) { |
| gotoxy(0, i); |
| printf("#"); |
| gotoxy(WIDTH + 1, i); |
| printf("#"); |
| } |
| } |
| |
| void drawSnake(Snake* snake) { |
| int i; |
| for (i = 0; i < snake->size; i++) { |
| gotoxy(snake->body[i].x, snake->body[i].y); |
| printf("*"); |
| } |
| } |
| |
| void drawFruit(Fruit* fruit) { |
| gotoxy(fruit->position.x, fruit->position.y); |
| printf("@"); |
| } |
| |
| // Controller |
| void initGame(Snake* snake, Fruit* fruit) { |
| snake->size = 1; |
| snake->body[0].x = WIDTH / 2; |
| snake->body[0].y = HEIGHT / 2; |
| snake->direction.x = 0; |
| snake->direction.y = 1; |
| |
| fruit->position.x = rand() % WIDTH; |
| fruit->position.y = rand() % HEIGHT; |
| fruit->isEaten = 0; |
| } |
| |
| void updateSnake(Snake* snake) { |
| memmove(&snake->body[1], &snake->body[0], sizeof(Point) * (snake->size - 1)); |
| snake->body[0].x += snake->direction.x; |
| snake->body[0].y += snake->direction.y; |
| } |
| |
| void updateFruit(Snake* snake, Fruit* fruit) { |
| if (snake->body[0].x == fruit->position.x && snake->body[0].y == fruit->position.y) { |
| fruit->isEaten = 1; |
| snake->size++; |
| } |
| if (fruit->isEaten) { |
| fruit->position.x = rand() % WIDTH; |
| fruit->position.y = rand() % HEIGHT; |
| fruit->isEaten = 0; |
| } |
| } |
| |
| void updateDirection(Snake* snake, char key) { |
| switch (key) { |
| case 'w': |
| snake->direction.x = 0; |
| snake->direction.y = -1; |
| break; |
| case 's': |
| snake->direction.x = 0; |
| snake->direction.y = 1; |
| break; |
| case 'a': |
| snake->direction.x = -1; |
| snake->direction.y = 0; |
| break; |
| case 'd': |
| snake->direction.x = 1; |
| snake->direction.y = 0; |
| break; |
| } |
| } |
| |
| int isGameOver(Snake* snake) { |
| if (snake->body[0].x <= 0 || snake->body[0].x >= WIDTH || snake->body[0].y <= 0 || snake->body[0].y >= HEIGHT) |
| return 1; |
| int i; |
| for (i = 1; i < snake->size; i++) { |
| if (snake->body[0].x == snake->body[i].x && snake->body[0].y == snake->body[i].y) |
| return 1; |
| } |
| return 0; |
| } |
| |
| int main() { |
| Snake snake; |
| Fruit fruit; |
| char key; |
| |
| initGame(&snake, &fruit); |
| |
| while (1) { |
| drawBoard(); |
| drawSnake(&snake); |
| drawFruit(&fruit); |
| |
| if (_kbhit()) { |
| key = _getch(); |
| updateDirection(&snake, key); |
| } |
| |
| updateSnake(&snake); |
| updateFruit(&snake, &fruit); |
| |
| if (isGameOver(&snake)) { |
| break; |
| } |
| |
| Sleep(100); |
| system("cls"); |
| } |
| |
| printf("Game Over!\n"); |
| |
| return 0; |
| } |
| """ |
|
|
