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)