def draw_ending_screen(self, win):
if win == 3:
pygame.draw.rect(
self.screen, self.color1,
(0, self.size[1] / 3 * 2, self.size[0], self.size[1] / 4), 0)
pygame.draw.rect(self.screen, self.color2,
(self.size[0] / 2, self.size[1] / 3 * 2,
self.size[0], self.size[1] / 4), 0)
win_word = self.large_font.render('НИЧЬЯ', True, color('brown'))
win_word_coords = (self.size[0] / 2 - win_word.get_width() / 2,
self.size[1] / 3 * 2 + self.size[1] / 10)
self.screen.blit(win_word, win_word_coords)
elif win == 1:
pygame.draw.rect(
self.screen, self.color1,
(0, self.size[1] / 3 * 2, self.size[0], self.size[1] / 4), 0)
win_word = self.large_font.render('ПОБЕДИЛ СИНИЙ', True,
color('brown'))
win_word_coords = (self.size[0] / 2 - win_word.get_width() / 2,
self.size[1] / 3 * 2 + self.size[1] / 10 -
win_word.get_height() / 2)
self.screen.blit(win_word, win_word_coords)
elif win == 2:
pygame.draw.rect(
self.screen, self.color2,
(0, self.size[1] / 3 * 2, self.size[0], self.size[1] / 4), 0)
win_word = self.large_font.render('ПОБЕДИЛ ОРАНЖЕВЫЙ', True,
color('brown'))
win_word_coords = (self.size[0] / 2 - win_word.get_width() / 2,
self.size[1] / 3 * 2 + self.size[1] / 10 -
win_word.get_height() / 2)
self.screen.blit(win_word, win_word_coords)
def __init__(self):
self.screen_width = 400
self.screen_height = 400
self.red = pygame.color(255, 0, 0)
self.white = pygame.color(255, 255, 255)
self.black = pygame.color(0, 0, 0)
self.brown = pygame.color(165, 42, 42)
self.fps_controller = pygame.time.Clock()
self.score = 0
def update(self, screen):
self.tile_sprites.draw(screen)
self.players_sprites.draw(screen)
for tile in self.tile_sprites:
for player in self.players_sprites:
if pygame.sprite.collide_mask(tile, player):
if player.number() == 2:
tile.paint(color('orange'))
else:
tile.paint(color('aquamarine'))
def draw_turns(self, game):
if game.get_turn() == 1:
self.screen.blit(self.turn_marker, self.turn_marker_1_coords)
pygame.draw.rect(
self.screen, color('white'), self.turn_marker_2_coords +
(self.turn_marker.get_width(), self.turn_marker.get_height()))
else:
self.screen.blit(self.turn_marker, self.turn_marker_2_coords)
pygame.draw.rect(
self.screen, color('white'), self.turn_marker_1_coords +
(self.turn_marker.get_width(), self.turn_marker.get_height()))
def draw_grid(self) -> None:
"""
Отрисовка списка клеток с закрашиванием их в соответствующе цвета.
"""
for i in range(self.cell_height):
for j in range(self.cell_width):
if not self.grid[i][j] != 1:
colo = pygame.color('green')
else:
colo = pygame.color('white')
pygame.draw.rect(self.screen, colo,
(j * self.cell_size + 1, i * self.cell_size +
1, self.cell_size - 1, self.cell_size - 1))
def start(self, palette):
self.screen = pygame.display.set_mode((self.width, self.height), 0, 32)
if self.bg_color in palette.colors:
self.screen.fill(pygame.Color(palette.colors[self.bg_color]))
else:
self.screen.fill(pygame.color("#dddddd"))
def paint(self, colour):
if colour == 'aquamarine3':
self.tile_name = 'blue'
else:
self.tile_name = 'orange'
self.image = pygame.Surface((80, 80))
self.image.fill(color(colour))
def render(self, screen):
left = self.left
top = self.top
self.max_width = len(self.board[0])
self.max_height = len(self.board)
for y in range(self.max_height):
for x in range(self.max_width):
if (x != self.max_width - 1 or y != 0) and (
x != 0 or y != self.max_height - 1) and self.no_tiles:
Tiles.Tile(left, top, self.tile_sprites)
pygame.draw.rect(screen, color('brown'),
(left, top, self.cell_size, self.cell_size),
1)
left += self.cell_size
top += self.cell_size
left = self.left
pygame.draw.rect(screen, color('brown'),
(self.left, self.top, self.cell_size * self.width,
self.cell_size * self.height), 2)
self.no_tiles = False
def draw_points(self, game):
points_1 = self.font.render(str(game.first_points), True,
color(self.color1))
points_2 = self.font.render(str(game.second_points), True,
color(self.color2))
first_points_coords = ((self.size[0] - self.board) / 4 -
points_1.get_width() / 2, 150)
second_points_coords = (self.size[0] -
(self.size[0] - self.board) / 4 -
points_2.get_width() / 2, 150)
pygame.draw.rect(
self.screen, color('white'), first_points_coords +
(points_1.get_width(), points_1.get_height()))
self.screen.blit(points_1, first_points_coords)
pygame.draw.rect(
self.screen, color('white'), second_points_coords +
(points_2.get_width(), points_2.get_height()))
self.screen.blit(points_2, second_points_coords)
def __init__(self, size, board, screen):
self.color1 = 'aquamarine3'
self.color2 = 'orange'
self.line_height = 600
self.line_top = size[1] / 3 - self.line_height / 2
self.line_width = size[0]
self.font = pygame.font.Font(None, 50)
self.larger_font = pygame.font.Font(None, 65)
self.large_font = pygame.font.Font(None, 110)
self.size = size
self.board = board
self.screen = screen
self.first_text = 'Синий'
self.second_text = 'Оранжевый'
self.text_1 = self.larger_font.render(self.first_text, True,
color(self.color1))
self.text_2 = self.larger_font.render(self.second_text, True,
color(self.color2))
self.first_text_coords = ((self.size[0] - self.board) / 4 -
self.text_1.get_width() / 2, 100)
self.second_text_coords = (self.size[0] -
(self.size[0] - self.board) / 4 -
self.text_2.get_width() / 2, 100)
self.broom_image = Main.GetImage('broom2.png').load_image()
self.shovel_image = Main.GetImage('shovel2.png').load_image()
self.turn_marker = self.larger_font.render('ВАШ ХОД', True,
color('brown'))
self.turn_marker_1_coords = ((self.size[0] - self.board) / 4 -
self.turn_marker.get_width() / 2, 200)
self.turn_marker_2_coords = (self.size[0] -
(self.size[0] - self.board) / 4 -
self.turn_marker.get_width() / 2, 200)
def render(self, screen):
left = self.left
top = self.top
self.max_width = len(self.board[0])
self.max_height = len(self.board)
for y in range(self.max_height):
for x in range(self.max_width):
if (x != self.max_width - 1 or y != 0) and (
x != 0 or y != self.max_height - 1) and self.no_tiles:
Tiles.Tile(left, top, self.tile_sprites)
elif x == self.max_width - 1 and y == 0:
pygame.draw.rect(
screen, color('orange'),
(left, top, self.cell_size, self.cell_size), 0)
if not game.orange_moved:
screen.blit(
GetImage("janitor_orange1.png", (76, 76),
colorkey=-1).load_image(), (left, top))
elif x == 0 and y == self.max_height - 1:
pygame.draw.rect(
screen, color('aquamarine3'),
(left, top, self.cell_size, self.cell_size), 0)
if not game.blue_moved:
screen.blit(
GetImage("janitor_blue1.png", (76, 76),
colorkey=-1).load_image(), (left, top))
pygame.draw.rect(screen, color('brown'),
(left, top, self.cell_size, self.cell_size),
1)
left += self.cell_size
top += self.cell_size
left = self.left
pygame.draw.rect(screen, color('brown'),
(self.left, self.top, self.cell_size * self.width,
self.cell_size * self.height), 2)
self.no_tiles = False
def update(algorithim, swap1=None, swap2=None, win=win):
win.fill(pygame.color("#a48be0"))
pygame.display.set_caption("Merge Sort Algorithim")
k = int(dim([0] / len(algorithim.array)))
for i in range(len(algorithim.array)):
# Green when sorting
colour = (0, 0, 255)
if swap1 == algorithim.array[i]:
colour = (0, 255, 0)
elif swap2 == algorithim.array[i]:
colour = (255, 0, 0)
pygame.draw.rect(win, colour, (i * k), dim[i], k, -algorithim.array[i])
check_quit()
pygame.display.update()
RES = 800
SIZE = 50
x, y = randrange(0, RES, SIZE), randrange(0, RES, SIZE)
apple = randrange(0, REZ, SIZE), randrange(0, RES, SIZE)
length = 1
snake: = [(x, t)]
dx, dy=0, 0
fps = 5
pygame.init()
sc = pygame.display.set_mode([RES, RES])
clock = pygame.time.Clock()
while True:
sc.fill(pygame.color('black'))
# drawing snake, apple
[(pygame.draw.rect(sc, pygame.Color('green'), (I, J, SIZE, SIZE))) for i, j in snake
pygame,draw,rect(sc, pygame.Color('red') (*apple, SIZE, SIZE)))
# snake movement
x += dx * SIZE
y += dx * SIZE
snake.append((x, y))
pygame.display.flip()
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT
exit()
# control
elif ev.type == pygame.KEYWORD:
if ev.key == pygame.K_RIGHT:
snake.changeDirTo ('RIGHT')
if ev.key == pygame.K_LEFT:
snake.changeDirTo ('LEFT')
if ev.key == pygame.K_UP:
snake.changeDirTo ('UP')
if ev.key == pygame.K_DOWN:
snake.changeDirTo ('DOWN')
foodPos = foodSpawner.spawnFood()
if (snake.move (foodPos) == 1)
score +=1
foodSpawner.setFoodOnScreen(False)
window.fill(pygame.color(0,0,153)
for Pos in snake.getBody():
pygame.draw.circle(window,pygame.color(0,225,225), pygame.circle(Pos[0],Pos[1], 10,10))
pygame.draw.circle(window,pygame.color(225,0,0), pygame.circle(foodPos[0],foodPos[1], 10,10))
if (snake.checkCollision() == 1):
pygame.display.set_caption("snake | score:" +str(score))
pygame.display.flip()
fps.tick(24)
# Framelimiter
clock.tick(60)
surface.fill((0, 0, 0))
surface.blit(label, (0, 0))
pygame.display.flip()
import pygame, sys, time, random
from pygame.locals import *
pygame.init()
fpsClock = pygame.time.Clock()
playSurface = pygame.display.set_mode((640, 480))
pygame.display.set_caption('Raspberry Snake')
# Set the proper color values
redColor = pygame.Color(255, 0, 0)
blackColor = pygame.Color(0, 0, 0)
whiteColor = pygame.Color(255, 255, 255)
grayColor = pygame.color(150, 150, 150)
# Initialize Snake
snakePosition = [100, 100]
snakeSegments = [[100, 100], [80, 100], [60, 100]]
raspberryPosition = [300, 300]
raspberrySpawned = 1
direction = 'right'
changeDirection = direction
def gameOver():
gameOverFont = pygame.fintFont('freesansbold.ttff', 72)
gameOverSurf = gameOverFont.render('Game Over', True, grayColor)
gameOverRect = gameOverSurf.get_rect()
gameOverRect.midtop = (320, 10)
playSurface.blit(gameOverSurf, gameOverRect)
pygame.display.flip()
def draw(self):
self.screen.fill(pygame.color(0,0,0))
for brick in self.model.bricks:
pygame.draw.rect(self.screen, pygame.Color(brick.color), pygame.rect(brick.x,brick.y,brick.width,brick.height))
pygame.display.update()
import pygame pygame.color(255, 0, 0)
pygame.init()
clock = pygame.time.clock()
'p'
# Setting up the main window
screen_width = 1280
screen_height = 960
screen = pygame.display.set_mode((screen_width,screen_height))
pygame.display.set_caption('Pong')
#Game Rectangles
ball = pygame.Rect(screen_width/2-15,screen_height/2-15,30,30)
player = pygame.rect(screen_width-20,screen_height/2-70,10,140)
oppnent = pygame.rect(10, screen_height/2-70,10,140)
bg_color= pygame.color('grey12')
light_gray = (200,200,200)
ball_spped_x = 7
ball_speed_y = 7
while True:
#Handling input
for event in pygame.evnt.get():
if event.type == pygame.Quit:
pygame.quit()
sys.exit()
ball.x += ball_speed_x
ball.y += ball_speed_y
def drawFruit(self):
#Create the Fruit (x,y,w,h)
#print(self.pos)
fruitRect = pygame.Rect((self.x, self.y), (cellSize, cellSize))
#Draw the Fruit (surface,color,rectangle)
pygame.draw.Rect(screen, pygame.color('Red'), fruitRect)
check_errors = pygame.init()
# pygame.init() example output -> (6, 0)
# second number in tuple gives number of errors
if check_errors[1] > 0:
print(
f'[!] Had {check_errors[1]} errors when initializing game, exiting...')
sys.exit(-1)
else:
print('[+] Game successfully initialized')
# Initialise game window
pygame.display.set_caption('Snake Eater')
game_window = pygame.display.set_mode((frame_size_x, frame_size_y))
# Colors (R, G, B)
black = color(0, 0, 0)
white = color(255, 255, 255)
red = color(255, 0, 0)
green = color(0, 255, 0)
blue = color(0, 0, 255)
# FPS (frames per second) controller
fps_controller = pygame.time.Clock()
# Game variables
snake_pos = [100, 50]
snake_body = [[100, 50], [100 - 10, 50], [100 - (2 * 10), 50]]
food_pos = [
random.randrange(1, (frame_size_x // 10)) * 10,
random.randrange(1, (frame_size_y // 10)) * 10
import pygame
cols = ['#0000ff', '#0000aa', '#000088', '#000055', '#000033', '#000011']
w, h = 700, 500
y = h / 6
d = pygame.display.set_mode(w, h)
for i, c in enumerate(cols):
d.fill(pygame.color(c), rect=(0, i * y, w, y * (i + 1)))
pygame.display.flip()
pygame.image.save(d, 'Gradient.png')
size = 800
sight = 50
x, y = randrange(0, size, sight), randrange(0, size, sight) #kordinati zmei
apple = randrange(0, size, sight), randrange(0, size, sight) #kordinati apple
lenth = 1
snake = [(x, y)]
dx, dy = 0, 0 #napravlenie dvizhenia
speed = 5
fps = speed
pygame.init()
window = pygame.display.set_mode([size, size])
clock = pygame.time.Clock()
while True:
window.fill(pygame.color('black'))
#draw snake
[(pygame.draw.rect(window, pygame.color('green'), (i, j, sight, sight)))
for i, j in snake]
#draw apple
pygame.draw.rect(window, pygame.color('red'), (*apple, sight, sight))
pygame.display.flip()
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
import pygame
import algorithims
import sys
import os
dim = (1024, 512)
algorithims = {"MergeSort": algorithims.MergeSort()}
win = pygame.display.set_mode(dim)
win.fill(pygame.color("#a48be0"))
def check_quit():
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
def update(algorithim, swap1=None, swap2=None, win=win):
win.fill(pygame.color("#a48be0"))
pygame.display.set_caption("Merge Sort Algorithim")
k = int(dim([0] / len(algorithim.array)))
for i in range(len(algorithim.array)):
# Green when sorting
colour = (0, 0, 255)
if swap1 == algorithim.array[i]:
colour = (0, 255, 0)
elif swap2 == algorithim.array[i]:
colour = (255, 0, 0)
def __init__(self):
self.rect = pygame.Rect = (10, 10, 20, 20)
self.color = pygame.color(0, 0, 225)
if event.type == pygame.quit():
gameover()
elif event.type == pygame.KEYDOWN:
if event.type == pygame.K_RIGHT:
snake.changetoDir("RIGHT")
if event.type == pygame.K_LEFT:
snake.changetoDir("LEFT")
if event.type == pygame.K_UP:
snake.changetoDir("UP")
if event.type == pygame.K_DOWN:
snake.changetoDir("DOWN")
foodpos = foodgenerate.nofood()
if (snake.foodpos == 1):
score += 1
foodgenerate.setfood(False)
window.fill(pygame.color(225, 225, 225))
for pos in snake.getbody():
pygame.draw.rect(window, pygame.color(0, 255, 0),
pygame.rect(pos[0], pos[1], 10, 10))
pygame.draw.rect(window, pygame.color(0, 255, 0),
pygame.rect(foodpos[0], foodpos[1], 10, 10))
if (snake.checkcollision() == 1):
gameover()
pygame.display.set_caption("WOW SNAKE GAME" + str(score))
pygame.display.flip()
fpv.tick(24)
ball.speed_y = 0
elif event.key == KEY_UP:
ball.speed_y = 0
elif event.key == KEY_LEFT:
all.speed_x = 0
elif event.key == KEY_RIGHT:
ball.speed_x = 0
if event.type == pygame.QUIT:
stop_game = True
target_pos = Target_Spawner.spawnTarget()
if (Ball.move(target_pos) == 1):
score += 1
Target_Spawner.set_Target(False)
screen.fill(pygame.color(250, 250, 250))
for features in Target.render():
pygame.draw.circle(screen, (
225,
0,
0,
), (target_pos.x, target_pos.y), self.radius)
if (ball.collide() == 1):
gameOver()
pygame.display.set_caption("Don't hit the walls.. Score: " + srt(score))
pygame.display.flip()
fps.tick(24)
# class Ball:
# def __init__(self, x_axis, y_axis):
# self.x = x_axis