tests/tools/example_snake_files.py - main - githubmirror/gpt-engineer

tests/tools/example_snake_files.py
1 827 строк37 KB
Axel Theorell
Structure of tests dir now mimics project structure
12 ноя 2023, 12:20
12 ноя 2023, 12:208496fc6
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;
}
"""