SnakeGame

from kivy.config import Config
Config.set('graphics', 'fullscreen', 'auto')
from kivy.app import App
from kivy.uix.gridlayout import GridLayout
from kivy.uix.widget import Widget
from kivy.properties import StringProperty, ListProperty, NumericProperty
from kivy.core.window import Window
from kivy.clock import Clock
from kivy.lang import Builder
import random
from random import choice

width = Window.width
height = Window.height

def rand_pos():
  x = choice(range(10, width-100))
  y = choice(range(100, height-200))
  return (x, y)


def calc_dist(touch, side):
    x = touch[0]
    y = touch[1]

    dx = 100 * x// width
    dy = 100 * y// height

    if side == "bottomLeft":
        if dx < dy:
            return True

    if side == "bottomRight":
        br = 100 - dx
        if br < dy:
            return True

    if side == "topLeft":
        tl = 100 - dy
        if dx < tl:
            return True

    if side == "topRight":
        if dx > dy:
            return True
    return False

class Part(Widget):
    color = ListProperty([1,1,1,1])
    def __init__(self, **kw):
        super(Part, self).__init__(**kw)
        self.size = (40,40)
        self.change_color()

    def change_color(self):
        self.color = [round(random.random(), 1) for _ in range(3)]


class Board(GridLayout):
    move_x = 0
    move_y = 0
    body = list()
    step = 40

    def __init__(self, **kw):
        super(Board, self).__init__(**kw)
        self.new_game()

    def new_game(self):
        self.head = Part(pos= (500, 800))
        self.add_widget(self.head)

        self.food = Part()
        self.food.pos = rand_pos()
        self.add_widget(self.food)

        self.body = [self.head]
        Clock.schedule_interval(self.looper, .3)

    def clear(self):
        self.move_x = 0
        self.move_y = 0
        try:
            for part in self.body:
                self.remove_widget(part)
            self.remove_widget(self.food)
        except:
            pass
        del self.body[:]



    def on_touch_down(self, touch):
        self.move_x = 0
        self.move_y = 0
        spot = (touch.x, touch.y)
        head = (self.head.x, self.head.y)

        if spot[0] < head[0] and spot[1] < head[1]:
            if calc_dist(spot, "bottomLeft"):
                self.move_x = -self.step
            else:
                self.move_y = -self.step

        if spot[0] > head[0] and spot[1] > head[1]:
            if calc_dist(spot, "topRight"):
                self.move_x = self.step
            else:
                self.move_y = self.step

        if spot[0] < head[0] and spot[1] > head[1]:
            if calc_dist(spot, "topLeft"):
                self.move_x = -self.step
            else:
                self.move_y = self.step

        if spot[0] > head[0] and spot[1] < head[1]:
            if calc_dist(spot, "bottomRight"):
                self.move_x = self.step
            else:
                self.move_y = -self.step

    def create_part(self, poss, color):
        part = Part(pos = poss)
        part.color = color
        self.add_widget(part)
        self.body.append(part)


    before = None
    def looper(self, dt):
        current = (self.head.x, self.head.y)
        if self.head.x > self.x and self.head.x < self.width and self.head.y > self.y and self.head.y < self.height:
            self.head.x += self.move_x
            self.head.y += self.move_y

            for part in self.body[1:]:
                self.before = (part.x, part.y)
                part.pos = current
                current = self.before

            if self.head.collide_widget(self.food):
                color = self.food.color
                if not self.before:
                    self.before = current

                self.food.change_color()
                self.food.pos = rand_pos()

                self.create_part(self.before, color)
        else:
            self.clear()
            Clock.unschedule(self.looper)
            self.new_game()

class SnakeGameApp(App):
    def build(self):
        return Board(size = Window.size)

Builder.load_string("""
<Part>:
    size_hint:(None, None)
    canvas:
        Color:
            rgb: root.color
        Rectangle:
            size: self.size # 30, 30
            pos: self.pos

<Board>:
    canvas:
        Color:
            rgba: .4, .4, 1, 1
        Rectangle:
            size: self.size
            pos: self.pos
""")

if __name__ == "__main__":
    snakegame = SnakeGameApp()
    snakegame.run()