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 creer_sprites_str(self, chaine):
"""
Fonction qui créer les sprites du bouton à partir d'une chaine de
caractères.
"""
try:
assert isinstance(chaine, str)
except AssertionError:
raise ValueError(chaine, " n'est pas une chaine de caractère.")
# Créer les images
self.sprites["normal"] = sf.Image.create(
len(chaine) * 32, 64, sf.Color(255, 255, 255))
self.sprites["passage"] = sf.Image.create(
len(chaine) * 32, 64, sf.Color(255, 255, 255))
# Dessiner les caractères sur les images
for l, lettre in enumerate(chaine):
coord_lettre = ((ord(lettre) % 10) * 32, (ord(lettre) // 10) * 64,
32, 64)
self.sprites["normal"].blit(ASCII, (l * 32, 0), coord_lettre)
self.sprites["passage"].blit(ASCII_PASSAGE, (l * 32, 0),
coord_lettre)
# Transformer les images en textures
self.sprites["normal"].create_mask_from_color(sf.Color(255, 255, 255))
self.sprites["passage"].create_mask_from_color(sf.Color(255, 255, 255))
self.sprites["normal"] = sf.Texture.from_image(self.sprites["normal"])
self.sprites["passage"] = sf.Texture.from_image(
self.sprites["passage"])
def test_neq(self):
not_equal = [(sf.Color(0, 0, 0, 1), sf.Color(0, 1, 0, 0)),
(sf.Color(255, 255, 255,
255), sf.Color(254, 255, 255, 255))]
for c1, c2 in not_equal:
self.assertNotEqual(c1, c2)
def creer_sprites_str(self, message):
"""
Fonction qui créer le sprite du texte à partir d'une chaine de
caractères.
"""
try:
assert isinstance(message, str)
except AssertionError:
raise ValueError(message, " n'est pas une chaine de caractère.")
# Créer l'image
chaines = message.split("\n")
taille_chaine_max = sorted(chaines, key=lambda x: -len(x))[0]
self.sprites["normal"] = sf.Image.create(taille_chaine_max * 32,
len(chaines) * 64,
sf.Color(255, 255, 255))
# Dessiner les caractères sur l'image
for l, ligne in enumerate(chaines):
for c, caractere in enumerate(ligne):
coord_lettre = ((ord(caractere) % 10) * 32,
(ord(caractere) // 10) * 64, 32, 64)
self.sprites["normal"].blit(
ASCII,
(c * 32 +
(taille_chaine_max - len(ligne) * 32) // 2, l * 64),
coord_lettre)
# Transformer l'image en texture
self.sprites["normal"].create_mask_from_color(sf.Color(255, 255, 255))
self.sprites["normal"] = sf.Texture.from_image(self.sprites["normal"])
def __init__(self, width, height, cell_size): sf.Drawable.__init__(self) self.width = width self.height = height self.cell_size = cell_size self.cols = int(math.ceil((self.width / cell_size))) self.rows = int(math.ceil((self.height / cell_size))) self.cells = [[Cell() for _ in range(self.rows)] for _ in range(self.cols)] # Grid lines for drawing self.lines = sf.VertexArray(sf.PrimitiveType.LINES, 2*self.rows+2*self.cols) for x in range(self.cols): self.lines[2*x].position = (x*self.cell_size, 0) self.lines[2*x+1].position = (x*self.cell_size, self.height) self.lines[2*x].color = sf.Color(220, 220, 100, 50) self.lines[2*x+1].color = sf.Color(220, 220, 100, 50) for y in range(self.rows): self.lines[2*(y+self.cols)].position = (0, y*self.cell_size) self.lines[2*(y+self.cols)+1].position = (self.width, y*self.cell_size) self.lines[2*(y+self.cols)].color = sf.Color(220, 220, 100, 50) self.lines[2*(y+self.cols)+1].color = sf.Color(220, 220, 100, 50)
def update_sprites(self, dt):
if self.system:
if self.system.damage == 0:
self.icon_sprite.color = sf.Color(120, 120, 120, 255)
elif self.system.damage < self.system.max_power:
self.icon_sprite.color = sf.Color(255, 120, 50, 255)
elif self.system.damage == self.system.max_power:
self.icon_sprite.color = sf.Color(255, 0, 0, 255)
def draw(self, energy):
if energy > 50.0:
self._bar.fill_color = sf.Color(255 * (100 - energy) * 2 / 100,
255, 0, 255)
else:
self._bar.fill_color = sf.Color(255, 255 * energy / 50, 0, 255)
self._bar.size = (energy / 100 * self._orig_size[0],
self._orig_size[1])
self._window.draw(self._bar)
def color(self):
if self.age > self.lifeSpan / 2:
self.antShape.fill_color = sf.Color.BLACK
elif self.age > self.lifeSpan / 4:
self.antShape.fill_color = sf.Color(50, 50, 50)
else:
self.antShape.fill_color = sf.Color(100, 100, 100)
class GameManager:
logo_font = sf.Font.from_file("Data/Fonts/astron boy wonder.ttf")
game_font = sf.Font.from_file("Data/Fonts/moonhouse.ttf")
blue_color = sf.Color(60, 221, 255)
grey_color = sf.Color(56, 56, 56)
window_height = 640
window_width = 800
scale_factor = 1.2
class_1 = 1
class_2 = 2
class_3 = 0
def initialize(self, renderer, game, state, character_id, spritepath):
character = state.entities[character_id]
if character.team == constants.TEAM_RED:
team = "0"
else:
team = "1"
self.hudsprite = sfml.Sprite(
function.load_texture(constants.SPRITE_FOLDER + "huds/ammo/" +
spritepath + "/" + team + ".png"))
self.background_bar.location = self.bar.location
self.background_bar.color = sfml.Color(0, 0, 0, 255)
self.bar.color = sfml.Color(217, 217, 183, 255)
def __init__(self, window, manager):
super(MainMenuHandler, self).__init__(window, manager)
self.menubg = sfml.Sprite(function.load_texture(constants.SPRITE_FOLDER + "gameelements/menubackgrounds/%s.png" % random.randint(0,2)))
self.menubg.x = 200
self.color = tuple(self.manager.config.setdefault('menu_color', [0.7, 0.25, 0]))
self.color = sfml.Color(self.color[0] * 255, self.color[1] * 255, self.color[2] * 255)
def __init__(self, w, h, cs): self.GW = w self.GH = h self.CS = cs self.prev_idx = 1 self.curr_idx = 0 self.pad = 1 if cs > 2 else 0 # if cells are 2x2 px or smaller, disable padding self.ALIVE_COLOR = sf.Color(255, 128, 0) self.DEAD_COLOR = sf.Color(32, 32, 32) self.quads = sf.VertexArray( sf.PrimitiveType.QUADS ) self.cells = [] self.init_cells() self.randomize_cells()
def display_error():
# Create the main window
window = sf.RenderWindow(sf.VideoMode(800, 600), 'SFML Shader example')
# Define a string for displaying the error message
error = sf.Text("Sorry, your system doesn't support shaders")
error.position = (100.0, 250.0)
error.color = sf.Color(200, 100, 150)
# Start the game loop
while window.opened:
# Process events
for event in window.iter_events():
# Close window: exit
if event.type == sf.Event.CLOSED:
window.close()
# Escape key: exit
if (event.type == sf.Event.KEY_PRESSED
and event.code == sf.Keyboard.ESCAPE):
window.close()
# Clear the window
window.clear()
# Draw the error message
window.draw(error)
# Finally, display the rendered frame on screen
window.display()
def draw(self, target):
# First, update all the sprite positions
self.sprite.position = self.position + self.sprite_offset
self.shields_sprite.position = self.position + self.sprite_offset + self.shields_offset
for room in self.rooms:
room.set_position(self.sprite.position +
sf.Vector2(room.position.x *
const.block_size, room.position.y *
const.block_size) + self.room_offset)
if self.weapon_system:
for weapon in self.weapon_system.weapons:
weapon.sprite.origin = weapon.sprite.frame_dim / 2
weapon.sprite.position = self.sprite.position + weapon.position
if weapon.slot.rotate:
weapon.sprite.rotation = weapon.slot.rotation
if weapon.slot.mirror:
weapon.sprite.ratio = weapon.slot.scale
if self.alive:
# Draw everything
if self.shield_system:
self.shields_sprite.color = sf.Color(
255, 255, 255, self.shield_system.shields * (255 // 4))
target.draw(self.shields_sprite)
if self.weapon_system:
for weapon in self.weapon_system.weapons:
target.draw(weapon.sprite)
target.draw(self.sprite)
for room in self.rooms:
room.draw(target)
elif self.exploding:
for piece in self.hull_pieces:
target.draw(piece.sprite)
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 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 main():
window = sf.RenderWindow(sf.VideoMode(640, 480), 'Pixels test')
window.framerate_limit = 60
princess = sf.Image.load_from_file('princess.png')
new_image = sf.Image(princess.width, princess.height)
pixels = princess.get_pixels()
unpacker = struct.Struct('BBBB')
for i in xrange(princess.width):
for j in xrange(princess.height):
k = i * 4 + j * princess.width * 4
s = pixels[k:k + 4]
if s:
color = sf.Color(*unpacker.unpack(s))
mean = (color.r + color.g + color.b) / 3
color.r = color.g = color.b = mean
new_image[i, j] = color
else:
pass
texture = sf.Texture.load_from_image(new_image)
sprite = sf.Sprite(texture)
running = True
while running:
for event in window.iter_events():
if event.type == sf.Event.CLOSED:
running = False
window.clear(sf.Color.WHITE)
window.draw(sprite)
window.display()
window.close()
def __init__(self, window, manager):
super(LobbyHandler, self).__init__(window, manager)
self.menuitems = [
('Back to Main Menu', LobbyHandler.go_back),
('', None)
]
self.menubg = sfml.Sprite(function.load_texture(constants.SPRITE_FOLDER + "gameelements/menubackgrounds/0.png"))
self.menubg.x = 200
self.menubg.x = 200
self.color = tuple(self.manager.config.setdefault('menu_color', [0.7, 0.25, 0]))
self.color = sfml.Color(self.color[0] * 255, self.color[1] * 255, self.color[2] * 255)
self.sendbuf = b''
self.lobbysocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.num_servers = -1
self.servers_read = 0
self.lobbysocket.connect((constants.LOBBY_HOST, constants.LOBBY_PORT))
lobbyuuid = uuid.UUID(constants.LOBBY_MESSAGE_TYPE_LIST).get_bytes()
self.protocoluuid = uuid.UUID(constants.GG2_LOBBY_UUID).get_bytes()
self.send_all(lobbyuuid+self.protocoluuid)
self.compatuuid = uuid.UUID(constants.PYGG2_COMPATIBILITY_PROTOCOL).get_bytes()
def update(self, dt):
super(Player, self).update(dt=dt)
hor = Input.get_axis('horizontal')
ver = Input.get_axis('vertical')
if (hor < 0):
self.play(1)
elif (hor > 0):
self.play(0)
elif (ver < 0):
self.play(2)
elif (ver > 0):
self.play(3)
input = V2.normalize(sf.Vector2(hor, ver))
self.position = self.collider.move(input * dt * self.speed)
#self.move(sf.Vector2(hor, ver)*dt*self.speed)
if Input.get_key_down(sf.Keyboard.SPACE):
self.light_on = not self.light_on
self.no_light_circle.enabled = not self.light_on
Player.instance.set_layer(80 if not self.light_on else 0)
self.sprite.color = sf.Color.WHITE if self.light_on else sf.Color(
128, 128, 128)
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 loop(self):
self._window.clear(sf.Color(50, 50, 50))
self._cursor.setPosition(sf.Mouse.get_position(self._window))
self._cursor.rotate(2)
self._game_menu.dispatch()
self._window.draw(self._cursor)
self._window.display()
def update(self, elapsed_time):
for bullet in self.bullets:
bullet.update(elapsed_time)
self.check_bounds()
if self.is_dead:
return
if not self.plane_jumped and (self.plane.rotation <= 60
or self.plane.rotation >= 300):
self.plane.rotate(1.25 * self.direction)
if self.immortal and self.immortal.elapsed_time.seconds > IMMORTAL_TIME:
self.immortal = None
self.plane.color = sf.Color(255, 255, 255, 255)
if self.plane_jumped:
self.plane_speed.y = -200.0
if self.jump_time.elapsed_time.seconds < 0.25:
self.plane.rotate(-2.5 * self.direction)
else:
self.plane_jumped = False
self.jump_time = None
if self.plane.rotation % 300 > 60:
self.plane.rotation = (
300, 60)[self.plane.rotation * self.direction > 300]
if self.plane_speed.y <= 50 * GRAVITY:
self.plane_speed += sf.Vector2(0.0, GRAVITY)
self.plane.move(self.plane_speed * elapsed_time)
self.plane.update(sf.seconds(elapsed_time))
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 main_loop(self):
while not self.done:
delta = self.clock.restart().seconds
self.event_loop()
self.player.update(delta)
self.clear(sf.Color(255, 255, 255))
self.draw(self.player.image)
self.display()
def Update(self):
for event in self.window.events:
if type(event) is sfml.CloseEvent:
self.window.close()
self.core.Quit()
self.window.display()
self.window.clear(sfml.Color(0, 0, 0))
def __init__(self, window):
self._window = window
self._clear_color = sf.Color(255, 255, 255)
self._background_sprite = None
self._background_texture = None
self._window_opened = True
self._clock = sf.Clock()
self._fps = 30
self._frame_time = sf.milliseconds(1000 / self._fps)
def __init__(self, position, radius, speed):
self.speed = speed
self.image = sf.CircleShape()
self.image.outline_thickness = 10
self.image.radius = radius
self.image.origin = (radius, radius)
self.image.position = sf.Vector2(*position)
self.image.outline_color = sf.Color.BLACK
self.image.fill_color = sf.Color(255, 100, 200)
def __init__(self, name, position=MenuBarPosition.POSITION_TOP, size=35):
b.BaseComponent.__init__(self, name)
self.events.update({
'OnClick': None,
})
self._items = []
self._position = position
self._size = size
self._fill_color = sf.Color(153, 153, 153)
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 draw(self, target, states):
self._dt_cmp = datetime.now()
r, g, b, a = self._hwindow.fill_color
if (self._dt_cmp - self._dt).microseconds >= 200000 and b >= 10:
self._hwindow.fill_color = sf.Color(r, g, b - 10, a)
self._dt = self._dt_cmp
target.draw(self._hwindow, states)
else:
target.draw(self._hwindow)
