def __init__(self, window, game_menu):
self._window = window
self._game_menu = game_menu
self._font = settings.defaultFont
self._highscore = Highscore()
self._name = ""
self._titletext = sf.Text("Game Over", self._font, 50)
self._titletext_left = sf.Text("Game Over", self._font, 50)
self._titletext_up = sf.Text("Game Over", self._font, 50)
self._titletext_right = sf.Text("Game Over", self._font, 50)
self._titletext_down = sf.Text("Game Over", self._font, 50)
self._titletext_left.color = sf.Color.BLACK
self._titletext_up.color = sf.Color.BLACK
self._titletext_right.color = sf.Color.BLACK
self._titletext_down.color = sf.Color.BLACK
self._titletext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50)
self._titletext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,50)
self._titletext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50-1.5)
self._titletext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,50)
self._titletext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50+1.5)
self._scoretext = sf.Text("Points "+str(self._game_menu._points), self._font, 50)
self._enternametext = sf.Text("Enter Name!", self._font, 50)
self._enternametext_left = sf.Text("Enter Name!", self._font, 50)
self._enternametext_up = sf.Text("Enter Name!", self._font, 50)
self._enternametext_right = sf.Text("Enter Name!", self._font, 50)
self._enternametext_down = sf.Text("Enter Name!", self._font, 50)
self._enternametext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250)
self._enternametext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,250)
self._enternametext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250-1.5)
self._enternametext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,250)
self._enternametext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250+1.5)
self._enternametext_left.color = sf.Color.BLACK
self._enternametext_up.color = sf.Color.BLACK
self._enternametext_right.color = sf.Color.BLACK
self._enternametext_down.color = sf.Color.BLACK
self._nametext = sf.Text(self._name, self._font, 50)
self._nametext_left = sf.Text(self._name, self._font, 50)
self._nametext_up = sf.Text(self._name, self._font, 50)
self._nametext_right = sf.Text(self._name, self._font, 50)
self._nametext_down = sf.Text(self._name, self._font, 50)
self._nametext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350)
self._nametext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,350)
self._nametext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350-1.5)
self._nametext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,350)
self._nametext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350+1.5)
self._nametext_left.color = sf.Color.BLACK
self._nametext_up.color = sf.Color.BLACK
self._nametext_right.color = sf.Color.BLACK
self._nametext_down.color = sf.Color.BLACK
#backbutton
self._okbutton = Button(sf.Vector2((self._window.size[0]-150)/2,(self._window.size[1]-50)), #position
sf.Vector2(150,20), #size
sf.Color.GREEN, #background color
sf.Color.BLACK, #text color
sf.Color.RED, #outline color
2, #outline thickness
"OK", #lable
self._font, #font
17) #text size
def __init__(self):
self.window = sf.RenderWindow(sf.VideoMode(WIDHT, HEIGHT), TITLE,
sf.Style.DEFAULT, settings)
self.window.framerate_limit = FPS
self.clock = sf.Clock()
self.ball = sf.CircleShape(30)
self.ball.origin = self.ball.radius, self.ball.radius
self.ball.position = self.window.size / 2
x = randint(1, 5)
y = randint(1, 5)
if randint(0, 1) % 2 == 0:
x *= -1.0
if randint(0, 1) % 2 == 0:
y *= -1.0
self.ball_vel = sf.Vector2(x, y)
self.ball_sound = None
#sol çubuk
self.p_left = sf.RectangleShape((30, 200))
x = self.p_left.size.x / 2
y = (HEIGHT - self.p_left.size.y) / 2
self.p_left.position = sf.Vector2(x, y)
self.left_score = 0
#sağ çubuk
self.p_right = sf.RectangleShape((30, 200))
x = WIDHT - (self.p_right.size.x * 1.5)
y = (HEIGHT - self.p_left.size.y) / 2
self.p_right.position = sf.Vector2(x, y)
self.right_score = 0
self.font = None
def move(self, x, y):
self.vertices[0].position += sf.Vector2(x, y)
self.vertices[1].position += sf.Vector2(x, y)
self.vertices[2].position += sf.Vector2(x, y)
self.vertices[3].position += sf.Vector2(x, y)
self.local_bounds = self.vertices.bounds
self.make_position_dirty()
def testUpdateSpriteFrame(self):
topLeft = sf.Vector2(
self.base_entity._frame_size.x * self.base_entity._frame,
self.base_entity._frame_size.y * self.base_entity._direction)
self.base_entity.update_sprite_frame()
self.assertTrue(self.base_entity._sprite.texture_rectangle ==
sf.Rectangle(topLeft, self.base_entity._frame_size))
# change properties
self.base_entity._direction = LEFT
self.base_entity._frame = 2
# update topLeft variable
topLeft = sf.Vector2(
self.base_entity._frame_size.x * self.base_entity._frame,
self.base_entity._frame_size.y * self.base_entity._direction)
# check to make sure that sprite frame has not been updated
self.assertFalse(self.base_entity._sprite.texture_rectangle ==
sf.Rectangle(topLeft, self.base_entity._frame_size))
# update frame and check
# for equality
self.base_entity.update_sprite_frame()
self.assertTrue(self.base_entity._sprite.texture_rectangle ==
sf.Rectangle(topLeft, self.base_entity._frame_size))
def __init__(self, speed, starting_position, texture, window_rectangle,
collision_manager):
self.window_rectangle = window_rectangle
self.starting_position = starting_position
self.speed = speed
self.collision_manager = collision_manager
self.direction = 1 if speed > 0 else -1
# Plane
fly_anim = Animation()
fly_anim.texture = texture
fly_anim.add_frame(sf.Rectangle((0, 0), (88, 73)))
fly_anim.add_frame(sf.Rectangle((88, 0), (88, 73)))
fly_anim.add_frame(sf.Rectangle((176, 0), (88, 73)))
fly_anim.add_frame(sf.Rectangle((88, 0), (88, 73)))
self.plane = AnimatedSprite(sf.seconds(0.2), False, True)
self.plane.play(fly_anim)
self.plane.size = sf.Vector2(self.plane.global_bounds.width / 2,
self.plane.global_bounds.height / 2)
self.plane.origin = self.plane.global_bounds.width / 2.0, self.plane.global_bounds.height / 2.0
self.plane.scale((self.direction * 0.5, 0.5))
self.plane.position = self.starting_position
self.plane_speed = sf.Vector2(speed, 0)
self.is_dead = False
self.jump_time = None
self.plane_jumped = False
self.immortal = None
self.bullets = set()
SoundManager.play_player_appear_sound()
def gamelogic(layer, tilesets):
x = 0
y = 0
for data in layer['data']:
if data > 0:
for t in tilesets:
if (t['firstgid'] <= data):
tileset = t
break
id = data - t['firstgid'] + 1
if id == 1: #block
c = Entity()
c.set_collider(Collider())
c.set_position(sf.Vector2(x, y))
elif id == 2: #blob spawn
m = Blob()
m.set_position(sf.Vector2(x, y))
elif id == 6: #purple spawn
m = Purple()
m.set_position(sf.Vector2(x, y))
elif id == 10: #purple spawn
m = Witch()
m.set_position(sf.Vector2(x, y))
elif id == 3: #player spawn
p = Player()
p.set_position(sf.Vector2(x, y))
Scene.current().camera.set_parent(p)
x += 1
if (x >= layer['width']):
x = 0
y += 1
def update(self, delta):
# Backgrounds
self.backgrounds[0].move(sf.Vector2(-3, 0) * delta.seconds)
width = self.backgrounds[0].global_bounds.width
x_coord = self.backgrounds[0].position.x + width
self.backgrounds[1].position = sf.Vector2(x_coord, 0)
if self.backgrounds[0].position.x <= -width:
self.backgrounds[0], self.backgrounds[1] = \
self.backgrounds[1], self.backgrounds[0]
# Grounds
self.grounds[0].move(sf.Vector2(-5, 0) * delta.seconds)
width = self.grounds[0].global_bounds.width
x_coord = self.grounds[0].position.x + width
y_coord = HEIGHT - self.grounds[1].global_bounds.height
self.grounds[1].position = sf.Vector2(x_coord, y_coord)
if self.grounds[0].position.x <= -width:
self.grounds[0], self.grounds[1] = \
self.grounds[1], self.grounds[0]
self.bird_sprite.play(self.bird_animation)
self.bird_sprite.move(sf.Vector2(0, 1))
self.bird_sprite.update(delta)
def __init__(self, position=None, color=None): sf.Drawable.__init__(self) self.shape = sf.CircleShape(settings.ENTITY_SIZE/2) r = random.randrange(56, 256) g = random.randrange(56, 256) b = random.randrange(56, 256) self.shape.fill_color = sf.Color(r, g, b, 50) self.shape.outline_color = sf.Color(r, g, b, 200) self.shape.outline_thickness = 1 v_x = random.randrange(-max_speed, max_speed + 1) v_y = random.randrange(-max_speed, max_speed + 1) self.position = position self.velocity = sf.Vector2(v_x, v_y) self.line = sf.VertexArray(sf.PrimitiveType.LINES, 2) self.line[0].color = sf.Color(r, g, b, 200) self.line[1].color = sf.Color(r, g, b, 50) self.centre_of_mass = sf.Vector2() self.average_velocity = sf.Vector2() self.num_nearby_entities = 0
def _draw(self, target):
if self._position in [
MenuBarPosition.POSITION_TOP, MenuBarPosition.POSITION_LEFT
]:
pos = (0, 0)
if self._position == MenuBarPosition.POSITION_TOP:
bar = sf.RectangleShape(sf.Vector2(target.width, self._size))
elif self._position == MenuBarPosition.POSITION_LEFT:
bar = sf.RectangleShape(sf.Vector2(self._size, target.height))
elif self._position == MenuBarPosition.POSITION_BOTTOM:
pos = (0, target.height - self._size)
bar = sf.RectangleShape(sf.Vector2(target.width, self._size))
elif self._position == MenuBarPosition.POSITION_RIGHT:
pos = (target.width - self._size, 0)
bar = sf.RectangleShape(sf.Vector2(self._size, target.height))
else:
raise Exception(
"Bad Menu bar position value: Expected one of MenuBarPosition constant values."
)
bar.position = pos
bar.fill_color = self._fill_color
target.draw(bar)
for itm in self._items:
target.draw(itm)
def update(self, sight_blockers):
# split out pathfinding and sighting functions
# if player can be seen, and is in range, stop and fire
# else move towards player along path
for blocker in sight_blockers:
while not check_sight(self[0].position, self[1].position, blocker):
# set old dist as current dist
olddist = get_distance(self[0].position, self[1].position)
tx = int(self[1].position.x)
ty = int(self[1].position.y)
# setup points to check
for x in [tx - 5, tx, tx + 5]:
for y in [ty - 5, ty, ty + 5]:
if not point_rect_intersect(sf.Vector2(x, y),
blocker.global_bounds):
newdist = get_distance(self[0].position,
sf.Vector2(x, y))
if newdist < olddist:
olddist = newdist
newpos = x, y
# add newpos to vertex array
v = sf.Vertex()
v.position = sf.Vector2(newpos[0], newpos[1])
v.color = sf.Color.RED
self.append(self[1])
self[1] = v
for i in range(len(self)):
print "Point #" + str(i) + ": " + str(
self[i].position.x), str(self[i].position.y)
def _create_renderables(self):
self.polygon = sf.CircleShape(self.poly_radius)
self.polygon.fill_color = sf.Color.BLACK
self.polygon.position = sf.Vector2(int(self.pos_x * self.window_x),
int(self.pos_y * self.window_y))
self.polygon.origin = sf.Vector2(self.poly_radius, self.poly_radius)
return [self.polygon]
def render(self):
self.window.clear()
self.window.draw(self.ball)
self.window.draw(self.p_left)
self.window.draw(self.p_right)
#skor tutma kısmı
scr_lft_text = sf.Text(str(self.left_score))
scr_lft_text.font = self.font
scr_lft_text.character_size = 30
x = (self.window.size.x /
2) - scr_lft_text.global_bounds.width - MARGIN
y = 50
scr_lft_text.position = sf.Vector2(x, y)
scr_lft_text.color = sf.Color.WHITE
self.window.draw(scr_lft_text)
scr_rgt_text = sf.Text(str(self.right_score))
scr_rgt_text.font = self.font
scr_rgt_text.character_size = 30
x = (self.window.size.x /
2) - scr_rgt_text.global_bounds.width + MARGIN
y = 50
scr_rgt_text.position = sf.Vector2(x, y)
scr_rgt_text.color = sf.Color.WHITE
self.window.draw(scr_rgt_text)
self.window.display()
def add_button(self, system):
x_offset = self.BUTTON_OFFSET_X + (len(self.buttons) * (self.BUTTON_WIDTH + self.BUTTON_RIGHT_MARGIN)) + self.BUTTON_RIGHT_MARGIN
next_button_location = sf.Vector2(x_offset, self.BUTTON_OFFSET_Y)
rectangle = sf.RectangleShape()
rectangle.position = next_button_location
rectangle.size = sf.Vector2(self.BUTTON_WIDTH, self.BUTTON_HEIGHT)
rectangle.fill_color = self.SYSTEM_BUTTON_COLOR
self.buttons.append(SystemButton(rectangle, system))
def ratio(self, value):
self._ratio = value
if self.texture_rectangle.width == 0 or self.texture_rectangle.height == 0:
self.sprite.ratio = sf.Vector2(1, 1)
else:
self.sprite.ratio = sf.Vector2(
(value.x * 1.0) / self.texture_rectangle.width,
(value.y * 1.0) / self.texture_rectangle.height)
def check_cylinder_effect(self):
doodle_position = self.__hero.get_position()
if doodle_position.x <= -sheet.DOODLE_SIZE.x:
self.__hero.set_position(
sf.Vector2(sheet.WINDOW_SIZE.x - sheet.DOODLE_SIZE.x,
doodle_position.y))
if doodle_position.x >= sheet.WINDOW_SIZE.x:
self.__hero.set_position(sf.Vector2(0, doodle_position.y))
def draw(self, window, transform):
scale = sf.Vector2(window.width / 768.0, window.height / 768.0)
t = sf.Transform().scale(sf.Vector2(1, 1) * scale.y)
scaled_bounds = sf.Vector2(self.text.local_bounds.size.x * scale.y,
self.text.local_bounds.size.y * scale.y)
t.translate((window.size - scaled_bounds) / 2.0)
self.__renderstate.transform = t * self.global_transform
window.draw(self.text, self.__renderstate)
def __init__(self, layer=0, color=sf.Color.WHITE, texture=None):
super(SpriteEntity, self).__init__(layer)
(sf.Sprite, self).__init__(texture=texture)
self.sprite = sf.Sprite(texture)
self.sprite.color = color
self.ratio = sf.Vector2(1.0, 1.0)
self.origin = sf.Vector2(0.5, 0.5)
self.__renderstate = sf.RenderStates()
def on_mouse_button_pressed(self, mouse_button, x, y):
if contains(self.local_bounds, sf.Vector2(x, y)):
self.typing = True
if self.text.string == self.default_text: # if it's the default text, get rid of it
self.text.string = ""
elif not contains(self.local_bounds, sf.Vector2(x, y)):
self.typing = False
if self.text.string == "": # if you unclick it and there's nothing there, make it the default text
self.text.string = self.default_text
def _handle_simulation_results(self, packet):
# System stuff
systems_power = packet.read()
for system_id, power in systems_power.items():
self.system_index[system_id].power = power
self.system_index[system_id].on_power_changed()
# Weapon stuff
weapon_powered = packet.read() # {weap_id : room_id}
weapon_targets = packet.read() # {weap_id : bool}
projectile_hits = packet.read() # {weap_id : [(proj_index, bool)]}
# Weapon targets
for weap_id, powered in weapon_powered.items():
self.weapon_index[weap_id].powered = powered
# Weapon on/off
for weap_id, target_id in weapon_targets.items():
if target_id:
self.weapon_index[weap_id].target = self.room_index[target_id]
else:
self.weapon_index[weap_id].target = None
# Projectile hits
for weap_id, proj_hits in projectile_hits.items():
# Weapon is firing if there's any projectile hits
if len(proj_hits) > 0:
self.weapon_index[weap_id].firing = True
else:
self.weapon_index[weap_id].firing = False
# Projectile hits
for hit_tup in proj_hits:
proj_index = hit_tup[0]
hit = hit_tup[1]
hit_shields = hit_tup[2]
weapon = self.weapon_index[weap_id]
projectile = weapon.projectiles[proj_index]
projectile.target_room = self.weapon_index[weap_id].target
projectile.hit = hit
projectile.hit_shields = hit_shields
projectile.phase = 0
# Projectile travel path stuff
projectile.start_position = weapon.sprite.position + sf.Vector2(
30, 0)
projectile.to_offscreen_position = weapon.sprite.position + sf.Vector2(
1200, 0)
projectile.from_offscreen_position = weapon.sprite.position + sf.Vector2(
-100, -100)
if projectile.hit_shields:
target = weapon.target.sprite.position + weapon.target.sprite.global_bounds.size / 2
projectile.target_position = (
target - projectile.from_offscreen_position
) / 2.5 + projectile.from_offscreen_position
else:
projectile.target_position = weapon.target.sprite.position + weapon.target.sprite.global_bounds.size / 2
# Timing stuff
projectile.fire_time = proj_index * 0.5 # Fire each projectile half a second after the previous
if projectile.hit_shields:
projectile.hit_time = projectile.fire_time + 3
else:
projectile.hit_time = projectile.fire_time + 3 # Hit 3 seconds after fire
def __init__(self):
# Constants
window_size = sf.Vector2(640, 400) # TODO: Make these variable
self.game_size = sf.Vector2(320, 200)
# Init window
w, h = window_size
self.window = sf.RenderWindow(sf.VideoMode(w, h), "PyDreams 0.1")
self.window.vertical_synchronization = True
def make_button(x,y,w,h,rotate,color,outlineThickness,outlinecolor,scale = (1,1)):
new_btn = sf.RectangleShape()
new_btn.position = (sf.Vector2(x,y))
new_btn.size = (sf.Vector2(w,h))
new_btn.fill_color = (color)
new_btn.outline_thickness = outlineThickness
new_btn.outline_color = outlinecolor
new_btn.rotation = (rotate)
new_btn.ratio = (scale)
return new_btn
def __init__(self):
super(Witch, self).__init__({
'path': 'animations/monster/witch.png',
'quantity': 2,
'interval': 0.05,
'size': sf.Vector2(64, 64)
})
self.speed = 1.5
self.scale(sf.Vector2(2, 2))
self.collider.size = sf.Vector2(2, 2)
def __init__(self):
super(Blob, self).__init__({
'path': 'animations/monster/blob.png',
'quantity': 2,
'interval': 0.2,
'size': sf.Vector2(128, 96)
})
self.speed = 2
self.scale(sf.Vector2(2, 2))
self.collider.size = sf.Vector2(2, 2)
def draw_hull_points(self, target):
for i in range(0, self.hull_points):
res.ship_hull_point_rect.position = self.position + sf.Vector2(
2 + i * 16, -80)
target.draw(res.ship_hull_point_rect)
if self.shield_system:
for i in range(0, self.shield_system.shields):
res.ship_shield_point_rect.position = self.position + sf.Vector2(
2 + i * 16, -50)
target.draw(res.ship_shield_point_rect)
def __init__(self):
super(Purple, self).__init__({
'path': 'animations/monster/purple.png',
'quantity': 2,
'interval': 0.05,
'size': sf.Vector2(96, 96)
})
self.speed = 3.5
self.scale(sf.Vector2(2, 2))
self.collider.size = sf.Vector2(2, 2)
def draw(self, target):
for button in self.buttons:
target.draw(button.rectangle)
for i in range(0, button.system.max_power):
if i < button.system.power:
self.powered_bar.position = button.rectangle.position+sf.Vector2(3, button.rectangle.size.y-((self.powered_bar.size.y+2)*(i+1))-3)
target.draw(self.powered_bar)
elif i < button.system.max_power:
self.unpowered_bar.position = button.rectangle.position+sf.Vector2(3, button.rectangle.size.y-((self.powered_bar.size.y+2)*(i+1))-3)
target.draw(self.unpowered_bar)
def setUp(self):
# Animation stuff
dudeFrame = 6
dudeFrameCounter = 0
dudeFrameSpeed = 5
# load the textures for possible heroes
dudeTextures = []
characters = []
try:
dudeTextures.append(
sf.Texture.from_file("assets/sprites/dude0.png"))
dudeTextures.append(
sf.Texture.from_file("assets/sprites/dude1.png"))
dudeTextures.append(
sf.Texture.from_file("assets/sprites/dude2.png"))
except IOError:
print("ERROR")
exit(1)
for dudeTexture in dudeTextures:
characters.append(sf.Sprite(dudeTexture))
for i in range(len(characters)):
characters[i].ratio = sf.Vector2(4, 4)
characters[i].origin = texture_size / 2
characters[i].position = (game_size.x / (len(characters) + 1) *
(i + 1), game_size.y / 2)
topLeft = sf.Vector2(114, 0)
for character in characters:
character.texture_rectangle = sf.Rectangle(topLeft, texture_size)
level = 1
space = pm.Space()
sprite = characters[1]
# create hero's physical body
dude_body = pm.Body(50, pm.inf) # Has a weight, but cannot rotate
# create hero's boundaries
dude_poly = pm.Poly.create_box(dude_body, person_size)
dude_poly.friction = 1
dude_poly.collision_type = 3
jump_sensor = pm.Poly.create_box(dude_body,
size=(50, 2),
offset=(0, 65))
jump_sensor.sensor = True
jump_sensor.collision_type = 2
space.add(dude_body, dude_poly, jump_sensor)
self.base_entity = BaseEntity(dude_body, dude_poly, sprite,
sf.Vector2(19, 44))
def spawn_rocks(self):
if len(self.rocks) == 0:
rock_down = sf.Sprite(self.rock_down)
rock_down.position = sf.Vector2(float(WWIDTH), 0.0)
self.rocks.append(rock_down)
rock_up = sf.Sprite(self.rock_up)
rock_up.position = sf.Vector2(rock_up.position.x + 300.0, float(WHEIGHT - rock_up.global_bounds.height))
self.rocks.append(rock_up)
else:
print("Boş değil")
def update(self, delta):
self.circle.move(self.c_vel)
if not self.circle.radius < self.circle.position.y < HEIGHT - self.circle.radius:
x, y = self.c_vel
y *= -1.0
self.c_vel = sf.Vector2(x, y)
if not self.circle.radius < self.circle.position.x < WIDHT - self.circle.radius:
x, y = self.c_vel
x *= -1.0
self.c_vel = sf.Vector2(x, y)
self.circle.move(self.c_vel * delta * SPEED_FACTOR)
def __init__(self,
position=sf.Vector2(0, 0),
size=sf.Vector2(1, 1),
offset=sf.Vector2(0, 0)):
Collider.__all.add(self)
self.__offset = offset
self.__size = size
self.position = position #must use setter!
#self.recalculate_rect()
self.peaceful = True
self.event_handler = None
