Untitled

import pygame,sys,random
from pygame.math import Vector2

pygame.mixer.pre_init(44100,-16,2,512)
pygame.init()
cell_size = 40
cell_number = 20
screen = pygame.display.set_mode((cell_number * cell_size,cell_number * cell_size))
clock = pygame.time.Clock()
apple = pygame.image.load('Graphics/apple.png').convert_alpha()
game_font = pygame.font.Font('Font/PoetsenOne-Regular.ttf', 25)

SCREEN_UPDATE = pygame.USEREVENT
pygame.time.set_timer(SCREEN_UPDATE,150)

class SNAKE:
	
	def __init__(self):
		self.body = [Vector2(5,10),Vector2(4,10),Vector2(3,10)]
		self.direction = Vector2(0,0)
		self.new_block = False #boolean value
		
		self.head_up = pygame.image.load('Graphics/head_up.png').convert_alpha()
		self.head_down = pygame.image.load('Graphics/head_down.png').convert_alpha()
		self.head_right = pygame.image.load('Graphics/head_right.png').convert_alpha()
		self.head_left = pygame.image.load('Graphics/head_left.png').convert_alpha()
		
		self.tail_up = pygame.image.load('Graphics/tail_up.png').convert_alpha()
		self.tail_down = pygame.image.load('Graphics/tail_down.png').convert_alpha()
		self.tail_right = pygame.image.load('Graphics/tail_right.png').convert_alpha()
		self.tail_left = pygame.image.load('Graphics/tail_left.png').convert_alpha()

		self.body_vertical = pygame.image.load('Graphics/body_vertical.png').convert_alpha()
		self.body_horizontal = pygame.image.load('Graphics/body_horizontal.png').convert_alpha()

		self.body_tr = pygame.image.load('Graphics/body_tr.png').convert_alpha()
		self.body_tl = pygame.image.load('Graphics/body_tl.png').convert_alpha()
		self.body_br = pygame.image.load('Graphics/body_br.png').convert_alpha()
		self.body_bl = pygame.image.load('Graphics/body_bl.png').convert_alpha()
		self.crunch_sound = pygame.mixer.Sound('Sound/crunch.wav')


	def update_head_graphics(self):
		head_relation = self.body[1] - self.body[0]
		if head_relation == Vector2(1,0): 
			self.head = self.head_left
		elif head_relation == Vector2(-1,0): 
			self.head = self.head_right
		elif head_relation == Vector2(0,1): 
			self.head = self.head_up
		elif head_relation == Vector2(0,-1): # cooridantes
			self.head = self.head_down

	def update_tail_graphics(self):
		tail_relation = self.body[-2] - self.body[-1]
		if tail_relation == Vector2(1,0):
			self.tail = self.tail_left
		elif tail_relation == Vector2(-1,0):
			self.tail = self.tail_right
		elif tail_relation == Vector2(0,1):  # positive y 
			self.tail = self.tail_up
		elif tail_relation == Vector2(0,-1):  #negative y 
			self.tail = self.tail_down


	def draw_snake(self):
		self.update_head_graphics()
		self.update_tail_graphics()

		#for letter/word in ...:
		#* multiply
		for index, block in enumerate(self.body):
			x_pos = int(block.x * cell_size)
			y_pos = int(block.y * cell_size)
			block_rect = pygame.Rect(x_pos, y_pos, cell_size, cell_size)


			if index == 0:
				screen.blit(self.head, block_rect) #image, location 
			elif index == len(self.body)- 1:
				screen.blit(self.tail, block_rect)
			else:
				previous_block = self.body[index +1 ] - block 
				next_block = self.body[index -1] - block 

				if previous_block.x == next_block.x:
					screen.blit(self.body_vertical, block_rect)
				elif previous_block.y == next_block.y:
					screen.blit(self.body_horizontal, block_rect)
				
				else:
					if previous_block.x == -1 and next_block.y == -1 or previous_block.y == -1 and next_block.x == -1:
						screen.blit(self.body_tl, block_rect)
					elif previous_block.x == -1 and next_block.y == 1 or previous_block.y == 1 and next_block.x == -1:
						screen.blit(self.body_bl, block_rect)
					elif previous_block.x == 1 and next_block.y == -1 or previous_block.y == -1 and next_block.x == 1:
						screen.blit(self.body_tl, block_rect)
					elif previous_block.x == 1 and next_block.y == 1 or previous_block.y  == 1 and next_block.x == 1:
						screen.blit(self.body_br, block_rect)
		
	def move_snake(self):
		#[:] means your copying the list 	
		#[:-1] means copy everthing except the final item 

		if self.new_block == True:
			body_copy = self.body[:]
			body_copy.insert(0, body_copy[0] + self.direction)
			self.body = body_copy[:]

		else:
			body_copy = self.body[:-1] #copying everything but the final item 
			body_copy.insert(0, body_copy[0] + self.direction)
			self.body = body_copy[:]


	def add_block(self):
		self.new_block = True 

	def play_crunch_sound(self):
		self.crunch_sound.play()
	
	def reset(self):
		self.body = [Vector2(5,10), Vector2(4,10), Vector2(3,10)]
		self.direction = Vector2(0,0) 

class FRUIT:
	def __init__(self):
		self.randomise()
		
	def draw_fruit(self):
		fruit_rect = pygame.Rect(int(self.pos.x * cell_size), int(self.pos.y * cell_size), cell_size, cell_size)
		screen.blit(apple, fruit_rect)

	def randomise(self):
		self.x = random.randint(0, cell_number - 1)  #includes both start and end points 
		self.y = random.randint(0,cell_number -1)
		self.pos = Vector2(self.x, self.y)


#insert - add an item into the list, at a specifc point  = insert(location, adding)
#append - add an item into the list at the end =  append()
#class - blueprint(plan)  
#object - something created from the class

class MAIN:
	def __init__(self):
		self.snake = SNAKE()  #object
		self.fruit = FRUIT()  

	def draw_elements(self):
		self.snake.draw_snake()
		self.fruit.draw_fruit()
	
	def check_collision(self):
		if self.fruit.pos == self.snake.body[0]:
			self.fruit.randomise()
			self.snake.add_block()
			self.snake.play_crunch_sound()

		for block in self.snake.body[1:]:
			if block == self.fruit.pos:
				self.fruit.randomise()
	
	def check_fail(self):
		if not 0<= self.snake.body[0].x < cell_number or not 0<= self.snake.body[0].y <cell_number:
			self.game_over()

		for block in self.snake.body[1:]:
			if block == self.snake.body[0]:
				self.game_over()

	def update(self):
		self.snake.move_snake()  
		self.check_collision()
		self.check_fail()


	def game_over(self):
		self.snake.reset()



main_game = MAIN()	#object


while True:
	for event in pygame.event.get():
		if event.type == pygame.QUIT:
			pygame.quit()
			sys.exit()

		
        
	screen.fill((175,215,70))
	main_game.draw_elements()
	pygame.display.update()
	clock.tick(60)