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 main():
window = sf.RenderWindow(sf.VideoMode(640, 480),
'SFML RenderTexture example')
window.framerate_limit = 60
running = True
rect0 = sf.RectangleShape((5, 5))
rect0.position = (90, 50)
rect0.fill_color = sf.Color.GREEN
rect0.outline_color = sf.Color.BLUE
rect0.outline_thickness = 2.0
rect1 = sf.RectangleShape((20, 30))
rect1.position = (50, 50)
rect1.fill_color = sf.Color.CYAN
rt = sf.RenderTexture(110, 110)
rt.clear(sf.Color(0, 0, 0, 0))
rt.draw(rect0)
rt.draw(rect1)
rt.display()
s = sf.Sprite(rt.texture)
s.origin = (55, 55)
s.position = (320, 240)
while running:
for event in window.iter_events():
if event.type == sf.Event.CLOSED:
running = False
window.clear(sf.Color.WHITE)
s.rotate(5)
window.draw(s)
window.display()
window.close()
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 __init__(self, position, identity):
self.hunger = 0
self.proxAnt = 0
self.memory = 0
self.proxFood = [0, 0, 0, 0]
self.proxWall = [0, 0, 0, 0]
self.dirOut = 0
self.direction = 0
self.pos = position
self.id = id
#tells if previous action caused this ant to be inactive this time
self.holding = 0
self.age = 0
self.offspring = []
self.genScore = np.size(self.offspring)
self.lifeSpan = 4
#neural net
self.neuralNet = net.Net()
#rendering
self.antShape = sf.RectangleShape((10, 10))
self.antShape.position = (self.pos[0] * 10, self.pos[1] * 10)
def __init__(self, world):
self.window = sf.RenderWindow(sf.VideoMode(1024, 600),
"Emergency Facility Location Problem")
self.facilities = []
self.world = []
font = sf.Font.from_file("font.ttf")
for x in xrange(world.shape[0]):
for y in xrange(world.shape[1]):
demand = sf.Text(str(world[x, y]), font)
demand.character_size = 10
demand.color = sf.Color.BLUE
demand.position = (x * 20, y * 20)
area = sf.RectangleShape()
area.size = (20, 20)
area.fill_color = sf.Color(0, 0, 0, world[x, y] / 10 * 255)
area.position = (x * 20, y * 20)
self.world.append((area, demand))
self.stats = sf.Text(
"Iterations : 0000000000000000000 \nFitness : 0000000000000000000",
font)
self.stats.character_size = 14
self.stats.color = sf.Color.MAGENTA
self.stats.position = (self.window.size.x -
self.stats.local_bounds.width, 0)
def render(self, renderer, game, state, character):
anim_frame = int(character.animoffset)
if not character.onground(game, state):
anim_frame = 1
if character.intel:
anim_frame += 2
sprite = self.sprites[anim_frame]
if character.flip:
sprite.ratio = sfml.system.Vector2(-1, 1)
sprite.origin = self.spriteoffset_flipped
else:
sprite.ratio = sfml.system.Vector2(1, 1)
sprite.origin = self.spriteoffset
sprite.position = renderer.get_screen_coords(character.x, character.y)
renderer.window.draw(sprite)
#toggle masks
if game.toggle_masks:
rect_location = renderer.get_screen_coords(character.x,
character.y)
rect_size = character.collision_mask.get_size()
rect_mask = sfml.RectangleShape(rect_size)
rect_mask.fill_color = (sfml.Color(255, 0, 0, 125))
rect_mask.position = (rect_location)
renderer.window.draw(rect_mask)
def __init__(self, window, view, savedGame, allCardData):
self.window = window
self.view = view
self.playField = []
self.tokens = []
self.equipment = []
self.bossCard = self.getRandomCard(allCardData, "Creature")
self.bossCard.x = 25
self.bossCard.y = 110
self.bossCard.getHoverImage()
self.playerHP = 20
self.enemyHP = 20
#### CREATE GUI ELEMENTS HERE
self.enemyHPBox = HPBox(900, 200, 100, 100, 20)
self.playerHPBox = HPBox(900, 725, 100, 100, 20)
self.divider = sf.RectangleShape()
self.divider.size = (1500, 4)
self.divider.outline_color = sf.Color.CYAN
self.divider.position = (0, 700)
self.divider.fill_color = sf.Color(0, 100, 255, 255)
self.maxNumberOfTokens = 15
self.HPBoxes = [self.enemyHPBox, self.playerHPBox]
self.dice = Dice(self, self.tokens)
self.dice.x, self.dice.y = (850, 25)
self.dice.tables.createToken(4, 2)
#self.equipment.append(Equipment(247337,0,0,x=55,y=685))
self.equipment.append(Equipment(247337, 0, 0, x=55, y=715))
def draw(self, hoveritem):
self.window.draw(self.menubg)
rect = sfml.RectangleShape((200, 600))
rect.fill_color = self.color
self.window.draw(rect)
super(LobbyHandler, self).draw(hoveritem)
def __init__(self, dData):
Component.__init__(self, "BOX:%s" % (dData['componentID']), False, 1)
self._box = sf.RectangleShape(
(int(dData['width']), int(dData['height'])))
self._box.position = (int(dData['x']), int(dData['y']))
self._box.fill_color = sf.Color.WHITE
self._box.outline_color = sf.Color.RED
self._box.outline_thickness = 3.0
def __init__(self, window):
self._bar = sf.RectangleShape()
self._bar.position = (92, 0)
self._orig_size = (settings.windowWidth - self._bar.position[0], 38)
self._bar.size = (settings.windowWidth - self._bar.position[0], 38)
self._bar.fill_color = sf.Color.GREEN
self._window = window
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 __init__(self, window):
self._box = sf.RectangleShape()
self._box.size = (92, 38)
self._box.fill_color = sf.Color.WHITE
self._text = sf.Text("00000", settings.monospaceFont, 30)
self._text.color = sf.Color.BLACK
self._window = window
def __init__(self, x, y, start_number):
Actor.__init__(self)
self.start_number = start_number
self.sprite = sf.RectangleShape()
self.sprite.size = (50, 50)
self.sprite.outline_color = sf.Color.BLUE
self.sprite.outline_thickness = 2
self.position = (x, y)
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):
self.window = sf.RenderWindow(sf.VideoMode(WIDHT, HEIGHT), TITLE,
sf.Style.DEFAULT, settings)
self.circle = sf.CircleShape(50)
self.rectangle = sf.RectangleShape((150, 200))
self.rectangle.position = 200, 100
self.view = sf.View()
self.view.reset(sf.Rectangle((0, 0), self.window.size))
self.window.view = self.view
def __init__(self, ship):
self.ship = ship
self.buttons = [] # A list of SystemButton objects
self.unpowered_bar = sf.RectangleShape()
self.unpowered_bar.size = sf.Vector2(32, 8)
self.unpowered_bar.fill_color = sf.Color(0, 0, 0, 0)
self.unpowered_bar.outline_thickness = 1
self.unpowered_bar.outline_color = sf.Color(255, 255, 255, 255)
self.powered_bar = sf.RectangleShape()
self.powered_bar.size = sf.Vector2(32, 8)
self.powered_bar.fill_color = self.BAR_POWERED_COLOR
#self.powered_bar.outline_thickness = 3
#self.powered_bar.outline_color = sf.Color(0, 0, 0, 0)
self.add_button(self.ship.engine_system)
self.add_button(self.ship.weapon_system)
self.add_button(self.ship.shield_system)
def __init__(self, x, array):
self.pos = (x, 26)
self.foodShape = sf.RectangleShape((10, 10))
self.foodShape.fill_color = sf.Color(195, 132, 163)
self.foodShape.position = (self.pos[0] * 10, self.pos[1] * 10)
array[x][26] = 5
def _create_renderables(self):
size_x = int(self.l * self.window_x)
size_y = 25
rod = sf.RectangleShape(size=sf.Vector2(size_x, size_y))
rod.fill_color = sf.Color.BLACK
rod.origin = sf.Vector2(0, int(size_y / 2))
weight = sf.CircleShape(self.circle_radius)
weight.fill_color = sf.Color.BLUE
weight.origin = sf.Vector2(self.circle_radius - size_x,
self.circle_radius)
pivot = sf.CircleShape(int(size_y / 2))
pivot.fill_color = rod.fill_color
pivot.origin = sf.Vector2(pivot.radius, pivot.radius)
cart = sf.RectangleShape(size=sf.Vector2(size_x, 75))
cart.fill_color = sf.Color.GREEN
cart.origin = sf.Vector2(int(size_x / 2), 0)
return [cart, rod, weight, pivot]
def draw(self, target, states):
dx = self.rect.width / self.max_points
width = self.rect.width / (self.max_points + 1)
for i in range(0, self.max_points):
shape = sf.RectangleShape((width, self.rect.height))
shape.outline_color = self.color
shape.outline_thickness = 1
if i < self.points:
shape.fill_color = self.color
else:
shape.fill_color = sf.Color.TRANSPARENT
shape.position = (self.rect.position.x + i * dx,
self.rect.position.y)
target.draw(shape, states)
def draw(self, hoveritem=None):
x = self.offsetx
y = self.offsety
for item in self.menuitems:
if item is hoveritem:
width, height = self.font.stringSize(item[0])
rect = sfml.RectangleShape((width, height))
rect.fill_color = sfml.Color.RED
rect.position = (x, y)
self.window.draw(rect)
self.font.renderString(item[0], self.window, x, y)
y += self.spacing
self.window.display()
def __init__(self, x, y, width, height, hp):
self.x = x
self.y = y
self.width = width
self.height = height
self.hp = hp
self.hovered = False
self.characterDead = False
box = sf.RectangleShape()
box.size = (self.width, self.height)
box.outline_color = sf.Color.WHITE
box.outline_thickness = 3
box.fill_color = sf.Color.TRANSPARENT
box.position = (self.x, self.y)
self.box = box
def __init__(self,
mainScreen,
ruleTables,
x=0,
y=200,
width=200,
height=75,
text="DEEP IQ's Turn"):
self.tables = RuleTables(self, mainScreen)
self.x = x
self.y = y
self.width = width
self.height = height
self.text = text
self.message = "DEEP IQ waits idly. "
self.coolDown = sf.Clock()
self.canBeClicked = True
self.mainScreen = mainScreen
box = sf.RectangleShape()
box.size = (self.width, self.height)
box.outline_color = sf.Color.WHITE
box.outline_thickness = 3
box.fill_color = sf.Color.TRANSPARENT
box.position = (self.x, self.y)
self.box = box
buffers = [
sf.SoundBuffer.from_file(
os.path.join(os.getcwd(), "res", "dice0.ogg")),
sf.SoundBuffer.from_file(
os.path.join(os.getcwd(), "res", "dice0.ogg")),
sf.SoundBuffer.from_file(
os.path.join(os.getcwd(), "res", "dice1.ogg")),
sf.SoundBuffer.from_file(
os.path.join(os.getcwd(), "res", "dice2.ogg")),
sf.SoundBuffer.from_file(
os.path.join(os.getcwd(), "res", "dice3.ogg")),
sf.SoundBuffer.from_file(
os.path.join(os.getcwd(), "res", "dice4.ogg"))
]
self.sounds = []
for buffer in buffers:
sound = sf.Sound()
sound.buffer = buffer
self.sounds.append(sound)
def main():
window = sf.RenderWindow(sf.VideoMode(800, 600), 'Shape example')
window.framerate_limit = 60
running = True
clock = sf.Clock()
custom_shapes = [CustomShape()]
rectangles = []
circles = []
for i in range(30):
circle = sf.CircleShape(randint(5, 20))
circle.fill_color = random_color()
circle.position = random_position(window)
circles.append(circle)
for i in range(100):
rectangle = sf.RectangleShape((randint(10, 30), randint(10, 30)))
rectangle.position = random_position(window)
rectangle.fill_color = random_color()
rectangle.outline_color = random_color()
rectangle.outline_thickness = randint(1, 2)
rectangles.append(rectangle)
while running:
for event in window.iter_events():
if event.type == sf.Event.CLOSED:
running = False
frame_time = clock.restart().as_milliseconds()
for r in rectangles:
r.rotate(frame_time * 0.3)
window.clear(sf.Color.WHITE)
for shape in custom_shapes + rectangles + circles:
window.draw(shape)
window.display()
window.close()
def setUp(self):
lineString = "move 200 400 100 50 0 0 0 0.0 400 300 1"
space = pm.Space()
line = lineString.split()
dynamic_body = pm.Body(pm.inf, pm.inf)
dynamic_body.position = int(line[1]), int(line[2])
my_shape = pm.Poly.create_box(dynamic_body, (int(line[3]),int(line[4])))
my_shape.friction = float(line[8])
my_shape.collision_type = 2
space.add(my_shape)
my_graphic = sf.RectangleShape()
my_graphic.size = (int(line[3]), int(line[4]))
my_graphic.origin = my_graphic.size / 2
my_graphic.fill_color = sf.Color(int(line[5]),int(line[6]),int(line[7]))
my_graphic.position = (int(line[1]), int(line[2]))
self.block = MovingBlock(dynamic_body, my_shape, my_graphic,
pm.Vec2d(int(line[9]), int(line[10])), float(line[11]))
def _create_window(self, x, y):
pX = x * (self._windowWidth + self._borderWeight) + self._borderWeight
pY = y * (self._windowHeight + self._borderWeight) + self._borderWeight
window = sf.RectangleShape(
sf.Vector2(self._windowWidth, self._windowHeight))
window.fill_color = self._houseColor
window.position = sf.Vector2(pX, pY) + self._house_position
self._windows[x][y] = {
"window": window,
"status": False,
"create_time": datetime.now(),
"energyConsumption": 0,
"animating": None,
"a_creation_time": datetime.now(),
"isDrawn": False,
"hasBread": False,
"bread_creation_time": datetime.now()
}
def __init__(self, name, size, shadowtext="Type here"):
base.BaseComponent(self, name)
self.events.update({
'OnFocus': None,
'OnBlur': None,
})
self.shadowtext = shadowtext
self.x_rect = sf.RectangleShape()
self.x_rect.size = size
self.focused = False
self.hovered = False
self.font_color = sf.Color.BLACK
self.shadow_color = sf.Color(200, 200, 200)
self.text = ""
self.fontsize = 10
self.forefont = None
self.shadowfont = None
self._run_event('OnCreate')
def __init__(self, position, size, bgcolor, fgcolor, linecolor, linesize,
lable, font, fontsize):
self._position = position
self._size = size
self._bgcolor = bgcolor
self._fgcolor = fgcolor
self._linecolor = linecolor
self._linesize = linesize
self._lable = lable
self._font = font
self._fontsize = fontsize
#def RecShape():
#RectangleShape
self._recShape = sf.RectangleShape()
self._recShape.position = self._position
self._recShape.size = self._size
self._recShape.fill_color = self._bgcolor
self._recShape.outline_color = self._linecolor
self._recShape.outline_thickness = self._linesize
#def Rec():
#Rectangle
self._rec = sf.Rectangle(self._position, self._size)
#def Text():
#text
self._text = sf.Text()
self._text.string = self._lable
self._text.font = self._font
self._text.character_size = self._fontsize
self._text.style = sf.Text.BOLD
textpos = sf.Vector2(
(self._size[0] - self._text.local_bounds.size[0]) / 2,
self._size[1] - self._fontsize) + self._position
textpos = sf.Vector2(
textpos[0], (textpos[1] - (self._text.local_bounds.size[1] / 5)))
self._text.position = textpos
self._text.color = self._fgcolor
def __init__(self, multiverseID, power, toughness, x=0, y=0, extraText=""):
self.multiverseID = multiverseID
self.x = x
self.y = y
self.alive = True
self.outlineWidth = 700
self.outlineHeight = 16
self.power = str(power)
self.toughness = str(toughness)
self.hoverTexture = None
self.hoverSprite = None
self.canDisplayImage = False
self.defaultColor = sf.Color.WHITE
self.altColor = sf.Color.RED
self.currentColor = self.defaultColor
self.outline = sf.RectangleShape()
self.outline.size = (self.outlineWidth, self.outlineHeight)
self.outline.outline_color = self.currentColor
self.outline.outline_thickness = 2
self.outline.fill_color = sf.Color.TRANSPARENT
self.outline.position = (self.x, self.y)
self.extraText = extraText
self.textContent = (self.power + " / " + self.toughness + " " +
extraText)
# -*- coding:utf-8 -*-
import sfml as sf
WIDTH = 800
HEIGHT = 480
TITLE = "Cindiii"
window = sf.RenderWindow(sf.VideoMode(WIDTH, HEIGHT), TITLE)
alpha = 255
circle = sf.CircleShape(50)
circle.origin = circle.radius, circle.radius
circle.fill_color = sf.Color(18, 74, 34, alpha)
rectangle = sf.RectangleShape((50, 50))
rectangle.fill_color = sf.Color.BLUE
rectangle.origin = rectangle.size.x / 2, rectangle.size.y / 2
rectangle.position = 200, 200
while window.is_open:
for event in window.events:
if type(event) is sf.CloseEvent:
window.close()
if type(event) is sf.MouseWheelEvent:
alpha += event.delta
if not 0 <= alpha <= 255:
print "Al kırdın kırdııın!"
alpha = 0
circle.fill_color = sf.Color(18, 74, 34, alpha)
if type(event) is sf.KeyEvent:
if event.released and event.code is sf.Keyboard.ESCAPE:
window.close()
circle.position = sf.Mouse.get_position(window)
def run():
window = sf.RenderWindow(sf.VideoMode(WWIDTH, WHEIGHT), WTITLE)
window.framerate_limit = 60
# Background
bg_texture = sf.Texture.from_file("assets/images/background.png")
background = sf.Sprite(bg_texture)
# Ball
b_texture = sf.Texture.from_file("assets/images/ball.png")
ball = sf.CircleShape(35)
ball.texture = b_texture
ball.origin = 35, 35
ball.position = WWIDTH / 2.0, WHEIGHT / 2.0
speed = sf.Vector2(randint(-5, 5), randint(-5, 5)) * 50.0
# Paddle 1
paddle_1 = sf.RectangleShape((50, 175))
paddle_1.origin = 25.0, 82.5
paddle_1.position = 50, WHEIGHT / 2.0
# Paddle 2
paddle_2 = sf.RectangleShape((50, 175))
paddle_2.origin = 25.0, 82.5
paddle_2.position = WWIDTH - 50, WHEIGHT / 2.0
# Scores
scored = False
p1_score, p2_score = 0, 0
# Font
font = sf.Font.from_file("assets/fonts/kenvector.ttf")
# Texts
p1_score_text = sf.Text(str(p1_score))
p1_score_text.font = font
p1_score_text.character_size = 72
p1_score_text.color = sf.Color.WHITE
p1_score_text.position = 170, 100
p2_score_text = sf.Text(str(p2_score))
p2_score_text.font = font
p2_score_text.character_size = 72
p2_score_text.color = sf.Color.WHITE
p2_score_text.position = 570, 100
# Sound
s_buffer = sf.SoundBuffer.from_file("assets/sounds/tone1.ogg")
sound = sf.Sound(s_buffer)
# Clock
clock = sf.Clock()
while window.is_open:
for event in window.events:
if type(event) is sf.CloseEvent:
window.close()
# Close
if sf.Keyboard.is_key_pressed(sf.Keyboard.ESCAPE):
window.close()
elapsed = clock.elapsed_time.seconds
clock.restart()
# Inputs
if sf.Keyboard.is_key_pressed(sf.Keyboard.W):
paddle_1.move(sf.Vector2(0, -PADDLE_SPEED))
if paddle_1.position.y < paddle_1.origin.y:
paddle_1.position = sf.Vector2(paddle_1.position.x,
paddle_1.origin.y)
if sf.Keyboard.is_key_pressed(sf.Keyboard.S):
paddle_1.move(sf.Vector2(0, PADDLE_SPEED))
if paddle_1.position.y > WHEIGHT - paddle_1.origin.y:
paddle_1.position = sf.Vector2(paddle_1.position.x,
WHEIGHT - paddle_1.origin.y)
if sf.Keyboard.is_key_pressed(sf.Keyboard.UP):
paddle_2.move(sf.Vector2(0, -PADDLE_SPEED))
if paddle_2.position.y < paddle_2.origin.y:
paddle_2.position = sf.Vector2(paddle_2.position.x,
paddle_2.origin.y)
if sf.Keyboard.is_key_pressed(sf.Keyboard.DOWN):
paddle_2.move(sf.Vector2(0, PADDLE_SPEED))
if paddle_2.position.y > WHEIGHT - paddle_2.origin.y:
paddle_2.position = sf.Vector2(paddle_2.position.x,
WHEIGHT - paddle_2.origin.y)
if scored:
speed = sf.Vector2(randint(-5, 5), randint(-5, 5)) * 50.0
ball.position = WWIDTH / 2.0, WHEIGHT / 2.0
paddle_1.position = 50, WHEIGHT / 2.0
paddle_2.position = WWIDTH - 50, WHEIGHT / 2.0
scored = False
ball.move(speed * elapsed)
if ball.position.x < ball.origin.x or ball.position.x > WWIDTH - ball.origin.x:
scored = True
if ball.position.x < ball.origin.x:
p2_score += 1
else:
p1_score += 1
p1_score_text.string = str(p1_score)
p2_score_text.string = str(p2_score)
if ball.position.y < ball.origin.y or ball.position.y > WHEIGHT - ball.origin.y:
speed = sf.Vector2(speed.x, speed.y * -1.0)
p1_col = ball.global_bounds.intersects(paddle_1.global_bounds)
if p1_col:
sound.play()
if p1_col.top + p1_col.height / 2.0 > paddle_1.position.y:
y = (-1.0, 1.0)[speed.y > 0]
else:
y = (1.0, -1.0)[speed.y > 0]
x_factor = (1.0, 1.05)[-MAX_BALL_SPEED < speed.x < MAX_BALL_SPEED]
speed = sf.Vector2(speed.x * -1.0 * x_factor, speed.y * y)
p2_col = ball.global_bounds.intersects(paddle_2.global_bounds)
if p2_col:
sound.play()
if p2_col.top + p2_col.height / 2.0 > paddle_2.position.y:
y = (-1.0, 1.0)[speed.y > 0]
else:
y = (1.0, -1.0)[speed.y > 0]
x_factor = (1.0, 1.05)[-MAX_BALL_SPEED < speed.x < MAX_BALL_SPEED]
speed = sf.Vector2(speed.x * -1.0 * x_factor, speed.y * y)
# Rendering
window.clear(sf.Color.BLACK)
window.draw(background)
window.draw(ball)
window.draw(paddle_1)
window.draw(paddle_2)
window.draw(p1_score_text)
window.draw(p2_score_text)
window.display()
