gamebackup.py

import turtle
import time
import math
import keyboard
import random
import numpy as np

class Connection:
    def __init__(self, connectedNeuron):
        self.connectedNeuron = connectedNeuron
        self.weight = np.random.normal()
        self.dWeight = 0.0


class Neuron:
    eta = 0.001
    alpha = 0.01

    def __init__(self, layer):
        self.dendrons = []
        self.error = 0.0
        self.gradient = 0.0
        self.output = 0.0
        if layer is None:
            pass
        else:
            for neuron in layer:
                con = Connection(neuron)
                self.dendrons.append(con)

    def addError(self, err):
        self.error = self.error + err

    def sigmoid(self, x):
        return 1 / (1 + math.exp(-x * 1.0))

    def dSigmoid(self, x):
        return x * (1.0 - x)

    def setError(self, err):
        self.error = err

    def setOutput(self, output):
        self.output = output

    def getOutput(self):
        return self.output

    def feedForword(self):
        sumOutput = 0
        if len(self.dendrons) == 0:
            return
        for dendron in self.dendrons:
            sumOutput = sumOutput + dendron.connectedNeuron.getOutput() * dendron.weight
        self.output = self.sigmoid(sumOutput)

    def backPropagate(self):
        self.gradient = self.error * self.dSigmoid(self.output);
        
        for dendron in self.dendrons:
            dendron.dWeight = Neuron.eta * (
            self.gradient * dendron.connectedNeuron.output) + self.alpha * dendron.dWeight;
            dendron.weight = dendron.weight + dendron.dWeight;
            dendron.connectedNeuron.addError(dendron.weight * self.gradient);
        self.error = 0;


class Network:
    def __init__(self, topology):
        self.layers = []
        for numNeuron in topology:
            layer = []
            for i in range(numNeuron):
                if (len(self.layers) == 0):
                    layer.append(Neuron(None))
                else:
                    layer.append(Neuron(self.layers[-1]))
            layer.append(Neuron(None))
            layer[-1].setOutput(1)
            self.layers.append(layer)

    def setInput(self, inputs):
        for i in range(len(inputs)):
            self.layers[0][i].setOutput(inputs[i])

    def feedForword(self):
        for layer in self.layers[1:]:
            for neuron in layer:
                neuron.feedForword();

    def backPropagate(self, target):
        for i in range(len(target)):
            self.layers[-1][i].setError(self.layers[-1][i].getOutput()- target[i])
        for layer in self.layers[::-1]:
            for neuron in layer:
                neuron.backPropagate()

    def getError(self, target):
        err = 0
        for i in range(len(target)):
            e = (target[i] - self.layers[-1][i].getOutput())
            err = err + e ** 2
        err = err / len(target)
        err = math.sqrt(err)
        return err

    def getResults(self):
        output = []
        for neuron in self.layers[-1]:
            output.append(neuron.getOutput())
        output.pop()
        return output

    def getThResults(self):
        output = []
        for neuron in self.layers[-1]:
            o = neuron.getOutput()
            print(o)
            if (o > 0.5):
                o = 1
            else:
                o = 0
            output.append(o)
        output.pop()
        return output


class Car:
	def __init__(self, angle, x, y, xwidth, ywidth):
		self.nn = Network([5,4,4])
		self.magnitudeofvelocity = 0
		self.x = x
		self.y = y
		self.angle = angle
		self.xwidth = xwidth
		self.ywidth = ywidth
		self.deltax = magnitudeofvelocity*math.cos(self.angle/57.2958)
		self.deltay = magnitudeofvelocity*math.sin(self.angle/57.2958)
		self.deltax = round(deltax, 2)
		self.deltay = round(deltay, 2)
	def drawcar(self, angle, x, y, xwidth, ywidth):
		paskat = turtle.pos()
	
		turtle.speed(0)
		turtle.penup()
		turtle.goto(x,y)
		turtle.pendown()
		turtle.speed(0)
		turtle.setheading(angle)
	
	
		turtle.forward(xwidth)
		turtle.left(90)
		turtle.forward(ywidth)
		turtle.left(90)
		turtle.forward(xwidth)
		turtle.left(90)
		turtle.forward(ywidth)
		turtle.left(90)
		turtle.penup()
		turtle.goto(paskat)
	def checkcollision(self):
		if self.x > -240:
			if self.x < 260:
				if self.y > -100:
					if self.y < 200:
						return True
		if self.x < -500:
			return True
		if self.x > 500:
			return True
		if self.y > 500:
			return True
		if self.y < -500:
			return True
		return False

def checkcollisiongeneric(ax,ay):
	if ax > -240:
		if ax < 260:
			if ay > -100:
				if ay < 200:
					return True
	if ax < -480:
		return True
	if ax > 480:
		return True
	if ay > 480:
		return True
	if ay < -480:
		return True
	return False
	

def drawmap():
	paska = turtle.Turtle()

	paska.speed(0)
	
	paska.color("grey","grey")
	
	paska.penup()
	
	paska.setposition(-240,-100)
	paska.begin_fill()
	paska.pendown()
	paska.forward(500)
	paska.left(90)
	paska.forward(300)
	paska.left(90)
	paska.forward(500)
	paska.left(90)
	paska.forward(300)


turtle.screensize(960, 960)
time.sleep(1)

time.sleep(1)
drawmap()
time.sleep(1)

magnitudeofvelocity = 1
deltax = 1
deltay = 0
angle = 0
turtle.tracer(0,0)
drawmap()
brakingconstant = 0.2
cars = []
for i in range(100):
	cars.append(Car(0, random.randint(0, 100), random.randint(0,1000), 30, 10))
while True:
	
	turtle.clear()
	
	
	
	
	for car in cars:

		car.deltax = car.magnitudeofvelocity*math.cos(car.angle/57.2958)
		car.deltay = car.magnitudeofvelocity*math.sin(car.angle/57.2958)
		
		car.deltax = round(car.deltax, 6)
		
		car.deltay = round(car.deltay, 6)

		if car.checkcollision():
			car.deltax = 0
			car.deltay = 0
		
		
		car.x = car.x + car.deltax
		car.y = car.y + car.deltay
		car.drawcar(car.angle, car.x, car.y, 30, 10)
		
		if keyboard.is_pressed("w"):
			
			car.magnitudeofvelocity = car.magnitudeofvelocity + 0.01
		if keyboard.is_pressed("a"):
			car.angle = car.angle + magnitudeofvelocity*brakingconstant
		if keyboard.is_pressed("d"):
			car.angle = car.angle - magnitudeofvelocity*brakingconstant
		if keyboard.is_pressed("s"):
			car.magnitudeofvelocity = car.magnitudeofvelocity - 0.01
		
		car.magnitudeofvelocity = car.magnitudeofvelocity - 0.001
		if car.magnitudeofvelocity < 0:
			car.magnitudeofvelocity = 0
		inputti = [0,0,0,0,0]
		anglejuttu = -20+car.angle
		for i in range(5):
			if checkcollisiongeneric((car.x + 40*math.cos(anglejuttu/57.2958)), (car.y + 40*math.sin(anglejuttu/57.2958))):
				print("fetooffed")
				inputti[i] = 1
			else:
				inputti[i] = 0
			turtle.setheading(anglejuttu)
			turtle.penup()
			turtle.goto((car.x + 40*math.cos(anglejuttu/57.2958)), (car.y + 40*math.sin(anglejuttu/57.2958)))

			turtle.pendown()
			turtle.forward(100)
			turtle.penup()
			anglejuttu = anglejuttu + 10
		car.nn.setInput(inputti)
		car.nn.feedForword()
		results = car.nn.getResults()
		if results[0] > 0.5:
			car.magnitudeofvelocity = car.magnitudeofvelocity + 0.01
		if results[1] > 0.5:
			car.magnitudeofvelocity = car.magnitudeofvelocity - 0.01
		if results[2] > 0.5:
			car.angle = car.angle + magnitudeofvelocity*brakingconstant
		if results[3] > 0.5:
			car.angle = car.angle - magnitudeofvelocity*brakingconstant

	

	turtle.update()