snake-game

import random
import curses
import threading
from curses import textpad
import os

OPPOSITE_DIRECTION_DICT = {
    curses.KEY_UP: curses.KEY_DOWN,
    curses.KEY_DOWN: curses.KEY_UP,
    curses.KEY_RIGHT: curses.KEY_LEFT,
    curses.KEY_LEFT: curses.KEY_RIGHT
}

DIRECTIONS_LIST = [curses.KEY_RIGHT, curses.KEY_LEFT, curses.KEY_DOWN, curses.KEY_UP]
SNAKE = '#'
FOOD = '@'
BLANK = ' '


def beep():
    def beep_sound():
        os.system('afplay /System/Library/Sounds/Sosumi.aiff')

    t = threading.Thread(target=beep_sound)
    t.start()


def create_food(snake, box):
    """Simple function to find coordinates of food which is inside box and not on snake body"""
    food = None
    while food is None:
        food = [random.randint(box[0][0] + 1, box[1][0] - 1),
                random.randint(box[0][1] + 1, box[1][1] - 1)]
        if food in snake:
            food = None
    return food


def main():
    # initial settings
    std_scr = curses.initscr()
    curses.curs_set(0)
    curses.noecho()
    curses.cbreak()

    global FOOD
    global SNAKE
    FOOD = curses.ACS_PI
    SNAKE = curses.ACS_CKBOARD
    std_scr.keypad(True)
    std_scr.nodelay(True)
    std_scr.timeout(100)

    # create a game box
    sh, sw = std_scr.getmaxyx()
    box = [[3, 3], [sh - 3, sw - 3]]  # [[ul_y, ul_x], [dr_y, dr_x]]
    textpad.rectangle(std_scr, box[0][0], box[0][1], box[1][0], box[1][1])

    # create snake and set initial direction
    snake = [[sh // 2, sw // 2 + 1], [sh // 2, sw // 2], [sh // 2, sw // 2 - 1]]
    direction = curses.KEY_RIGHT

    # draw snake
    for y, x in snake:
        std_scr.addch(y, x, SNAKE)

    # create food
    food = create_food(snake, box)
    std_scr.addch(food[0], food[1], FOOD)

    # print score
    score = 0
    score_text = "Score: {}".format(score)
    std_scr.addstr(1, sw // 2 - len(score_text) // 2, score_text)

    while 1:
        # non-blocking input
        key = std_scr.getch()

        # set direction if user pressed any arrow key and that key is not opposite of current direction
        if key in DIRECTIONS_LIST and key != OPPOSITE_DIRECTION_DICT[direction]:
            direction = key

        # find next position of snake head
        head = snake[0]
        new_head = [head[0], head[1] + 1]
        if direction == curses.KEY_LEFT:
            new_head = [head[0], head[1] - 1]
        elif direction == curses.KEY_DOWN:
            new_head = [head[0] + 1, head[1]]
        elif direction == curses.KEY_UP:
            new_head = [head[0] - 1, head[1]]

        # insert and print new head
        std_scr.addch(new_head[0], new_head[1], SNAKE)
        snake.insert(0, new_head)

        # if snake head is on food
        if snake[0] == food:
            # update score
            curses.beep()
            beep()
            curses.flash()
            score += 1
            score_text = "Score: {}".format(score)
            std_scr.addstr(1, sw // 2 - len(score_text) // 2, score_text)

            # create new food
            food = create_food(snake, box)
            std_scr.addch(*food, FOOD)

            # increase speed of game
            std_scr.timeout(100 - (len(snake) // 3) % 90)
        else:
            # shift snake's tail
            std_scr.addstr(snake[-1][0], snake[-1][1], BLANK)
            snake.pop()

        # conditions for game over
        if (snake[0][0] in [box[0][0], box[1][0]] or
                snake[0][1] in [box[0][1], box[1][1]] or
                snake[0] in snake[1:]):
            msg = "Game Over!"
            std_scr.addstr(sh // 2, sw // 2 - len(msg) // 2, msg)
            std_scr.nodelay(False)
            std_scr.getch()
            break

    curses.curs_set(1)
    curses.nocbreak()
    std_scr.keypad(False)
    curses.echo()
    curses.endwin()
    quit()


if __name__ == '__main__':
    main()