Untitled

import pygame,sys,random
from pygame.math import Vector2
#Vector2 - 2d
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
		
		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]  #body - head 
		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):
			self.head = self.head_down

		
	def update_tail_graphics(self):
		#pass - placeholder, when there is no code
		tail_relation = self.body[-2] - self.body[-1]  #body - tail 
		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):
			self.tail = self.tail_up
		elif tail_relation  == Vector2(0,-1):
			self.tail = self.tail_down
	
#class - blueprint (plan)
#objects - something created from the blueprint (class) 
	def move_snake(self):  
		if self.new_block == True:
			#listname[:] makes a copy 
			body_copy = self.body[:]
			#adding an item to a list at a specific position in the list -  insert(postion, item)
			#append - add an item to the list 
			body_copy.insert(0, body_copy[0] + self.direction)
			self.body = body_copy[:]
			self.new_block = False  #reset every move 

		else:
			body_copy = self.body[:-1]   #[:-1] copy list except from final item
			body_copy.insert(0, body_copy[0] + self.direction)
			self.body = body_copy[:]


	def draw_snake(self):
		self.update_head_graphics()
		self.update_tail_graphics()
#enemurate  - loop through list and returns more than 1 (e.g index, block)
		for index,block in enumerate(self.body):
			x_pos = int(block.x * cell_size) # correct format pixels 
			y_pos = int(block.y * cell_size)
			block_rect = pygame.Rect(x_pos, y_pos, cell_size, cell_size )

			if index == 0: #head
				screen.blit(self.head, block_rect)
			elif index == len(self.body) -1:   #len() starts from 1,  tail
				screen.blit(self.tail, block_rect)
			else: #body 
				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: #turns 
					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_tr, 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 play_crunch_sound(self):
		self.crunch_sound.play()

	def add_block(self):
		self.new_block = True

	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) 
		self.y = random.randint(0, cell_number - 1)
		self.pos = Vector2(self.x, self.y)


#range(0,50) - final value is not included
#randint() - final endpoint is included in the ramdom number generator

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

	def draw_elements(self):
		self.snake.draw_snake()
		self.fruit.draw_fruit()
	
	def check_collisions(self):
		if self.fruit.pos == self.snake.body[0]:
			self.snake.play_crunch_sound()
			self.snake.add_block()
			self.fruit.randomise()
		
		for block in self.snake.body[1:]: 
			if block == self.fruit.pos:   # if the rest of the body collides with the fruit
				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 game_over(self):
		self.snake.reset()
	
	def update(self):
		self.snake.move_snake()
		self.check_fail()
		self.check_collisions()
		
			

main_game = MAIN()  #object

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

		if event.type == SCREEN_UPDATE:
			main_game.update()

		if event.type == pygame.KEYDOWN: #checking if any key has been pressed 
			if event.key == pygame.K_UP:  # Up arrow
				if main_game.snake.direction.y != 1: #negative 
					main_game.snake.direction = Vector2(0, -1)
			
			if event.key == pygame.K_RIGHT:
				if main_game.snake.direction.x != -1:
					main_game.snake.direction = Vector2(1,0)

			if event.key == pygame.K_DOWN:
				if main_game.snake.direction.y != -1:
					main_game.snake.direction = Vector2(0,1)
			
			if event.key == pygame.K_LEFT:
				if main_game.snake.direction.x != 1:
					main_game.snake.direction = Vector2(-1, 0)



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