def main():
pygame.init()
pygame.key.set_repeat(10, 10)
clock = pygame.time.Clock()
surface = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Squah game")
font = pygame.font.Font(None, 80)
message_over = font.render("Game Over!!", True, (255, 0, 0))
message_pos = message_over.get_rect()
message_pos.centerx = surface.get_rect().centerx
message_pos.centery = surface.get_rect().centery
ball_num = 3
racket = Rect(RACKET_SIZE)
ball = Rect(surface.get_rect().centerx - 10, 0, BALL_SIZE, BALL_SIZE)
dir = randint(ANGLE, 180 - ANGLE)
speed = INIT_SPEED
game_over = False
while True:
# キーの判定
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == KEYDOWN:
if event.key == K_LEFT:
racket.centerx -= 10
elif event.key == K_RIGHT:
racket.centerx += 10
elif event.key == K_UP:
racket.centery -= 10
elif event.key == K_DOWN:
racket.centery += 10
# 判定ボールの移動
if ball.centery < HEIGHT:
ball.centerx += cos(radians(dir)) * speed
ball.centery += sin(radians(dir)) * speed
else:
if ball_num > 1:
ball_num -= 1
ball.left = surface.get_rect().centerx - 10
ball.top = 0
dir = randint(ANGLE, 180 - ANGLE)
else:
game_over = True
if racket.colliderect(ball):
dir = -(90 + (racket.centerx - ball.centerx) / racket.width * 100)
print(dir)
if ball.centerx < 0 or ball.centerx > WIDTH:
dir = 180 - dir
dir = -dir if ball.centery < 0 else dir
surface.fill((255, 255, 255))
if game_over:
surface.blit(message_over, (message_pos))
pygame.draw.rect(surface, RACKET_COLOR, racket)
pygame.draw.ellipse(surface, BALL_COLOR, ball)
pygame.display.update()
clock.tick(30)
class BlowDart(object):
def __init__(self, displayRect, startPos, charPos, facing, damage):
self.SIZE = int(displayRect[2] * .04)
self.IMAGE = pygame.image.load('Resources/Sprites/Blow_Dart.png')
self.IMAGE = pygame.transform.scale(self.IMAGE, (self.SIZE//3, self.SIZE))
self.IMAGE = pygame.transform.rotate(self.IMAGE, facing)
self.IMAGE = self.IMAGE.convert_alpha()
self.damage = damage
x,y = self.IMAGE.get_size()
self.POS = list(startPos)
self.VEC = vec2.vecFromPoints(startPos, charPos)
self.VEC.normalizeIP()
self.RECT = Rect(startPos + [x, y])
self.SPEED = 10
self.onScreen = True
self.hit = False
def returnBlitPos(self, displayRect):
x = self.POS[0] - displayRect[0]
y = self.POS[1] - displayRect[1]
return (x,y)
def returnImage(self):
return self.IMAGE
def __damageChar(self, char):
cenDart = (self.RECT[0] + self.RECT[2]//2, self.RECT[1] + self.RECT[3]//2)
if not self.hit and char.RECT[0] < cenDart[0] < char.RECT[0] + char.RECT[2] and char.RECT[1] < cenDart[1] < char.RECT[1] + char.RECT[3]:
char.health -= self.damage
self.hit = True
def update(self, displayRect, Char):
self.POS = [self.POS[0] + int(self.VEC.x * self.SPEED), self.POS[1] + int(self.VEC.y * self.SPEED)]
self.RECT.x, self.RECT.y = self.POS[0], self.POS[1]
self.onScreen = self.RECT.colliderect(displayRect)
self.__damageChar(Char)
class RpgSprite(pygame.sprite.Sprite):
def __init__(self, spriteFrames, position = (0, 0)):
pygame.sprite.Sprite.__init__(self)
# properties common to all RpgSprites
self.spriteFrames = spriteFrames
self.position = [i * SCALAR for i in position]
self.image, temp = self.spriteFrames.advanceFrame(0)
# indicates if this sprite stands upright
self.upright = True
# indicates if this sprite is currently visible
self.inView = False
# indicates if this sprite is currently masked by any map tiles
self.masked = False
# indicates if this sprite should be removed on next update
self.toRemove = False
def setup(self, uid, rpgMap, eventBus):
self.uid = uid
self.rpgMap = rpgMap
self.eventBus = eventBus
def setTilePosition(self, tx, ty, level):
self.x, self.y = tx, ty
self.setPixelPosition(tx * TILE_SIZE + self.position[0],
ty * TILE_SIZE + self.position[1],
level)
def setPixelPosition(self, px = 0, py = 0, level = None):
# main rect
self.rect = self.image.get_rect()
# other rectangles as required by the game engine
self.mapRect = self.image.get_rect()
self.initBaseRect()
# if required, move to the requested position
if level:
self.level = level
if px > 0 or py > 0:
self.doMove(px, py)
def initBaseRect(self):
baseRectWidth = self.mapRect.width
baseRectHeight = BASE_RECT_HEIGHT
if hasattr(self, "baseRectSize"):
baseRectWidth = self.baseRectSize[0]
baseRectHeight = self.baseRectSize[1]
baseRectTop = self.getBaseRectTop(baseRectHeight)
baseRectLeft = (self.mapRect.width - baseRectWidth) / 2
self.baseRect = Rect(baseRectLeft, baseRectTop, baseRectWidth, baseRectHeight)
# print self.uid, self.baseRect.width, self.baseRect.height
def getBaseRectTop(self, baseRectHeight):
return self.mapRect.bottom - baseRectHeight
def doMove(self, px, py):
self.mapRect.move_ip(px, py)
self.baseRect.move_ip(px, py)
# a pseudo z order is used to test if one sprite is behind another
self.z = int(self.mapRect.bottom + self.level * TILE_SIZE)
def clearMasks(self):
if self.masked:
self.masked = False
self.spriteFrames.repairCurrentFrame()
def applyMasks(self):
# masks is a map of lists, keyed on the associated tile points
masks = self.rpgMap.getMasks(self)
if len(masks) > 0:
self.masked = True
for tilePoint in masks:
px = tilePoint[0] * view.TILE_SIZE - self.mapRect.left
py = tilePoint[1] * view.TILE_SIZE - self.mapRect.top
[self.image.blit(mask, (px, py)) for mask in masks[tilePoint]]
def advanceFrame(self, increment, metadata):
self.image, frameIndex = self.spriteFrames.advanceFrame(increment, **metadata)
self.playSound(frameIndex)
def playSound(self, frameIndex):
pass
def isIntersecting(self, sprite):
if self != sprite and self.level == sprite.level and self.baseRect.colliderect(sprite.baseRect):
return True
return False;
def processCollision(self, player):
pass
def processAction(self, player):
pass
import pygame
import time
import os
from pygame.locals import QUIT, MOUSEBUTTONDOWN, KEYDOWN, \
K_SPACE, K_ESCAPE, K_UP, K_DOWN, Rect
# 0 - Menu principal
# 1 - Jogando
# 2 - Pausado
# 3 - Menu configuracao
estado = 0
indice_menu = 0
r1 = Rect((10, 10), (50, 100))
r2 = Rect((20, 20), (100, 100))
if r1.colliderect(r2):
print ("Colidiu")
clk = pygame.time.Clock()
tempo = 0
def calcular_menu( menu_opcoes ):
global indice_menu
for opcao in menu_opcoes:
opcao_renderizada = font.render(opcao["text"], True, opcao["cor"])
opcao["surface"] = opcao_renderizada
opcao["rect"] = opcao_renderizada.get_rect()
opcao["rect"].x = opcao["pos"][0]
opcao["rect"].y = opcao["pos"][1]
if indice_menu < 0:
indice_menu = 0
class Entity:
def __init__(self):
self.Sprite = Sprite.Sprite()
self.start = (0, 0)
self.end = (0, 0)
self.dim = Rect(0, 0, 0, 0)
self.on = False
self.shaders = ("", "")
self.anim_rate= -1
self.anim_fn = ""
# Various entity attributes
self.phyz = False
self.anim = False
self.static = False
self.p_spawn = False
self.e_spawn = False
def Load(self, filename=None, surface=None):
if(filename): self.Sprite.Load(filename=filename)
elif surface: self.Sprite.Load(surface=surface)
return self
def Update(self, x, y):
if not self.on: return
self.Sprite.Move(x, y)
self.end = (x, y)
def Pan(self, x, y):
self.start = (self.start[0] + x, self.start[1] + y)
self.end = (self.end[0] + x, self.end[1] + y)
self.dim.x += x
self.dim.y += y
def Enable(self, x, y):
self.on = True
self.start = (x, y)
self.end = (x, y)
self.dim.x = x
self.dim.y = y
def Disable(self, x, y):
self.on = False
def Collide(self, rect):
return self.dim.colliderect(rect)
def Render(self, screen):
# Calculate how many should be rendered.
count_x = abs(self.start[0] - self.end[0]) / self.Sprite.GetW()
count_y = abs(self.start[1] - self.end[1]) / self.Sprite.GetH()
# Fix dimensions.
self.dim.topleft = self.start
self.dim.w = (count_x + 1) * self.Sprite.GetW()
self.dim.h = (count_y + 1) * self.Sprite.GetH()
# Render count_x * count_y copies.
for x in xrange(count_x + 1):
for y in xrange(count_y + 1):
coord = (self.start[0] + (x * self.Sprite.GetW()), \
(self.start[1] + (y * self.Sprite.GetH())))
screen.blit(self.Sprite.GetSprite(), coord)
return self
def BuildMeshString(self):
return MESH_FORMAT % \
(self.GetW(), self.GetW(), self.GetH(), self.GetH(), \
self.GetH() / (1.0 * self.Sprite.GetH()), \
self.GetW() / (1.0 * self.Sprite.GetW()), \
self.GetH() / (1.0 * self.Sprite.GetH()), \
self.GetW() / (1.0 * self.Sprite.GetW()), \
os.path.splitext(os.path.basename(self.Sprite.GetFilename()))[0] + ".tga")
def TogglePhysics(self):self.phyz = not self.phyz; return self.phyz
def ToggleStatic(self): self.static = not self.static; return self.static
def TogglePSpawn(self): self.p_spawn = not self.p_spawn; return self.p_spawn
def ToggleESpawn(self): self.e_spawn = not self.e_spawn; return self.e_spawn
def IsAnimation(self): return self.anim
def IsPhysical(self): return self.phyz
def IsStatic(self): return self.static
def IsSpawn(self): return self.p_spawn or self.e_spawn
def HasShader(self): return self.shaders[0] != "" or self.shaders[1] != ""
def GetX(self): return self.start[0]
def GetY(self): return self.start[1]
def GetW(self): return self.dim.w
def GetH(self): return self.dim.h
def _GetRect(self): return self.dim
def GetFilename(self): return self.Sprite.GetFilename()
def GetVShader(self): return self.shaders[0]
def GetFShader(self): return self.shaders[1]
def ToggleAnimation(self): self.anim = not self.anim; return self.anim
def GetAnimationFilename(self): return self.anim_fn
def GetAnimationRate(self): return self.anim_rate
class RpgSprite(pygame.sprite.Sprite):
def __init__(self, spriteFrames, position=(0, 0)):
pygame.sprite.Sprite.__init__(self)
# properties common to all RpgSprites
self.spriteFrames = spriteFrames
self.position = [i * SCALAR for i in position]
self.image, temp = self.spriteFrames.advanceFrame(0)
# indicates if this sprite stands upright
self.upright = True
# indicates if this sprite is currently visible
self.inView = False
# indicates if this sprite is currently masked by any map tiles
self.masked = False
# indicates if this sprite should be removed on next update
self.toRemove = False
def setup(self, uid, rpgMap, eventBus):
self.uid = uid
self.rpgMap = rpgMap
self.eventBus = eventBus
def setTilePosition(self, tx, ty, level):
self.tilePosition = (tx, ty)
self.setPixelPosition(tx * TILE_SIZE + self.position[0],
ty * TILE_SIZE + self.position[1], level)
def setPixelPosition(self, px=0, py=0, level=None):
# main rect
self.rect = self.image.get_rect()
# other rectangles as required by the game engine
self.mapRect = self.image.get_rect()
self.initBaseRect()
# if required, move to the requested position
if level:
self.level = level
if px > 0 or py > 0:
self.doMove(px, py)
def initBaseRect(self):
baseRectWidth = self.mapRect.width
baseRectHeight = BASE_RECT_HEIGHT
if hasattr(self, "baseRectSize"):
baseRectWidth = self.baseRectSize[0]
baseRectHeight = self.baseRectSize[1]
baseRectTop = self.getBaseRectTop(baseRectHeight)
baseRectLeft = (self.mapRect.width - baseRectWidth) / 2
self.baseRect = Rect(baseRectLeft, baseRectTop, baseRectWidth,
baseRectHeight)
# print self.uid, self.mapRect, self.baseRect
def getBaseRectTop(self, baseRectHeight):
return self.mapRect.bottom - baseRectHeight
def doMove(self, px, py):
self.mapRect.move_ip(px, py)
self.baseRect.move_ip(px, py)
# a pseudo z order is used to test if one sprite is behind another
self.z = int(self.mapRect.bottom + self.level * TILE_SIZE)
# print self.uid, self.mapRect, self.baseRect
def clearMasks(self):
if self.masked:
self.masked = False
self.spriteFrames.repairCurrentFrame()
def applyMasks(self):
# masks is a map of lists, keyed on the associated tile points
masks = self.rpgMap.getMasks(self)
if len(masks) > 0:
self.masked = True
for tilePoint in masks:
px = tilePoint[0] * view.TILE_SIZE - self.mapRect.left
py = tilePoint[1] * view.TILE_SIZE - self.mapRect.top
[self.image.blit(mask, (px, py)) for mask in masks[tilePoint]]
def advanceFrame(self, increment, metadata):
self.image, frameIndex = self.spriteFrames.advanceFrame(
increment, **metadata)
self.playSound(frameIndex)
def playSound(self, frameIndex):
pass
def isIntersecting(self, sprite):
if self != sprite and self.level == sprite.level and self.baseRect.colliderect(
sprite.baseRect):
return True
return False
def processCollision(self, player):
pass
def processAction(self, player):
pass
class Pong(object):
def __init__(self, screensize, id):
self.screensize = screensize
self.id = id
# place ball in the center
self.centerx = int(screensize[0] * 0.5)
self.centery = int(screensize[1] * 0.5)
self.radius = 8
# create shape and sizes it
self.rect = Rect(self.centerx - self.radius,
self.centery - self.radius, self.radius * 2,
self.radius * 2)
self.color = const.WHITE
self.direction = [1, 1] # current direction to the right and up
# list so we can access each individual part because it will change
self.speedx = 2
self.speedy = 5
self.hit_left_edge = False
self.hit_right_edge = False
self.ai_score = 0
self.player_score = 0
self.player_paddle_win = False
self.ai_paddle_win = False
self.play_sound = False
def update(self, player_list):
self.play_sound = False
self.centerx += self.direction[0] * self.speedx
self.centery += self.direction[1] * self.speedy
self.rect.center = (self.centerx, self.centery)
# makes sure if ball hits top it comes back down
if self.rect.top <= 0:
self.direction[1] = 1
elif self.rect.bottom >= self.screensize[1] - 1:
self.direction[1] = -1 # bounce up and down
elif self.rect.right >= self.screensize[0] - 1:
self.direction[0] = -1
elif self.rect.left <= 0:
self.direction[0] = 1
# checks if the code above is true
if self.rect.right >= self.screensize[
0] - 1: # if it's greater than width -1
self.hit_right_edge = True
elif self.rect.left <= 0:
self.hit_left_edge = True
if self.rect.top <= 0:
self.hit_right_edge = True
elif self.rect.bottom >= self.screensize[1] - 1:
self.hit_left_edge = True
#Resets score after all player leave and restart game
if len(player_list) < 1:
self.reset_score()
# check for a collision between the rectangles
for player in player_list:
if player.side == 0:
if self.rect.colliderect(player.rect):
self.direction[0] = -1
self.play_sound = True
self.player_score += 1
if self.player_score == 15: # win if you score 15 points
time.sleep(.4)
self.player_paddle_win = True
else:
if self.rect.colliderect(player.rect):
self.direction[0] = 1
self.play_sound = True
self.ai_score += 1
if self.ai_score == 15: # lose if the computer scores 15 points
time.sleep(.4)
self.ai_paddle_win = True
def get_info(self):
info = {
"id": self.id,
"x": self.centerx,
"y": self.centery,
"lscore": self.ai_score,
"rscore": self.player_score,
"rwin": self.player_paddle_win,
"lwin": self.ai_paddle_win,
"sound": self.play_sound
}
return info
def reset_score(self):
self.player_score = 0
self.ai_score = 0
self.ai_paddle_win = False
self.player_paddle_win = False
x = random.randint( 0, WIDTH-1 )
y = 0
delx = dely = 5
RorL = random.randint(0,1)
if RorL == 0:
delx = -delx
GREEN = (0,255,0)
racket = Rect( (WIDTH//2, HEIGHT-50, 80, 10) )
point = 0
while True:
key_event()
surface.fill( WHITE )
pygame.draw.rect(surface, GREEN, racket)
pygame.draw.circle( surface, RED, (x,y), RADIUS )
ball_rect = Rect( (x-RADIUS, y-RADIUS, RADIUS*2, RADIUS*2) )
if racket.colliderect( ball_rect ):
point += 10
dely = -dely
if y<0:
dely = -dely
if x>=WIDTH or x<0:
delx = -delx
if y>=HEIGHT:
surface.blit( text, textpos )
# break
x += delx
y += dely
pygame.display.set_caption( 'Squash POINT=' + str(point) )
pygame.display.update()
clock.tick( FPS )
WHITE = (255, 255, 255)
RED = (255, 0, 0)
RADIUS = 10
x = random.randint(0, WIDTH - 1)
y = 0
delx = dely = 5
GREEN = (0, 255, 0)
SIZE = (WIDTH // 2, HEIGHT - 50, 80, 10)
racket = Rect(SIZE)
while True:
key_event()
surface.fill(WHITE)
pygame.draw.rect(surface, GREEN, racket)
pygame.draw.circle(surface, RED, (x, y), RADIUS)
ball_rect = Rect((x - RADIUS, y - RADIUS, RADIUS * 2, RADIUS * 2))
if y < 0 or racket.colliderect(ball_rect):
dely = -dely
if x < 0 or x >= WIDTH:
delx = -delx
if y >= HEIGHT:
print('Game over')
break
x += delx
y += dely
pygame.display.update()
clock.tick(FPS)
fine()
def step(self, keys, space_pressed):
"""
ゲーム進行処理
"""
self.score += conf.SCORE_INC_STEP
# レベルアップ
self.level_up()
# 操作受付
if keys[K_LEFT]:
self.player.p_x -= conf.MOVE_X_STEP + conf.SCROLL_STEP
if keys[K_RIGHT]:
self.player.p_x += conf.MOVE_X_STEP
if space_pressed and self.player.is_landing:
self.player.is_going_jump = True
if not (keys[K_LEFT] or keys[K_RIGHT]):
# キー未入力時は画面スクロールとともに自機も左へ流れる
self.player.p_x -= self.scroll_step
# 横歩行の壁を超えない
if self.player.p_x <= 0:
self.player.p_x = 0
elif self.player.p_x >= conf.SCREEN_WIDTH:
self.player.p_x = conf.SCREEN_WIDTH
# スクロール
self.scroll()
# ジャンプ、重力
self.jump_and_gravity()
# 接触判定のため、自機オブジェクトを仮で生成
player_char = Rect(
(self.player.p_x - 10, self.player.p_y),
(conf.PLAYER_SIZE, conf.PLAYER_SIZE),
)
# 自機と地面の接触判定
for f in self.floors:
if player_char.colliderect(f.rect):
# print("地面と接触")
self.player.is_landing = True
self.player.is_going_jump = False
self.player.p_y = f.top - conf.PLAYER_SIZE
# 地面と接触した場合、自機位置の補正
player_char = Rect(
(self.player.p_x - conf.PLAYER_SIZE / 2, self.player.p_y),
(conf.PLAYER_SIZE, conf.PLAYER_SIZE),
)
# 描画
self.screen.fill(conf.SCREEN_COLOR)
player_char = Rect(
(self.player.p_x - 10, self.player.p_y),
(conf.PLAYER_SIZE, conf.PLAYER_SIZE),
)
pygame.draw.rect(self.screen, conf.PLAYER_COLOR, player_char)
for f in self.floors:
# pygame.draw.rect(self.screen, conf.FLOOR_COLOR, f)
f.draw(self.screen)
# 穴に落ちたらゲームオーバー
if (self.player.p_y + conf.PLAYER_SIZE) >= conf.SCREEN_HEIGHT:
return GameStatus.GAME_OVER
return GameStatus.GAMING
