def __init__(self, width, height, interactive_mode=False):
self.width = width
self.height = height
self.start_height = height / 2
self.pipe_start_offset = 1000
self.pipe_distance = 300
self.pipe_space = 100
self.pipe_count = 5
self.horizontal_speed = 5
self.gravity = 0.5
self.interactive_mode = interactive_mode
self.external_draw = None
self.events = EventManager()
if interactive_mode:
# init pygame font
print("Initializing font... This might take a while.")
pygame.font.init()
self.game_font = pygame.font.SysFont("Arial", 30)
# init pygame clock
self.game_clock = pygame.time.Clock()
# init pygame display
pygame.display.init()
# set window dimensions
self.game_screen = pygame.display.set_mode((width, height))
# set window title
pygame.display.set_caption("FlappyAI")
self.reset()
def do_test(n_data_packets, cc, add_events):
"""
The test has 2 hosts connected by a link, and one flow.
"""
em = EventManager(logging=False)
host_1 = Host(em, 'H1', debug=False)
host_2 = Host(em, 'H2', debug=False)
sr = SeqNumberRecorder('S', host_2)
l1_a = Link(em, 'L1_a', host_1, sr, DATA_PACKET_SIZE * 1000, 0.01,
5 * DATA_PACKET_SIZE, debug=False)
l1_b = Link(em, 'L1_b', host_2, host_1, DATA_PACKET_SIZE * 1000, 0.01,
5 * DATA_PACKET_SIZE, debug=False)
host_1.link = l1_a
host_2.link = l1_b
flow = Flow(em, 'F1', host_1, host_2, n_data_packets * DATA_PACKET_SIZE, 1,
cc, debug=False)
add_events(em, host_1, host_2, sr, l1_a, l1_b, flow)
em.run()
assert sr.seqs == set(range(n_data_packets + 1))
# print('Src send first unacked', flow.src.send_first_unacked, 'Src send next', flow.src.send_next, 'Dst receive next', flow.dst.receive_next)
assert flow.src.last_seq_number == n_data_packets
assert flow.src.send_first_unacked == n_data_packets + 1
assert flow.src.send_next == n_data_packets + 1
assert flow.dst.receive_next == n_data_packets + 1
def Main():
"""main - main function calls all components and run the program."""
print("Base Application Running")
evManager = EventManager()
keybd = KeyboardController(evManager)
spinner = CPUSpinnerController(evManager)
pygameView = PygameView(evManager)
game = Game(evManager)
spinner.Run()
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = None
self.background_edit = None
self.background_connection = None
self.background_check = None
self.setBackground()
self.grid = [] #list of lines that define the grid
self.setup()
self.events = EventManager(self)
def build(self):
self.state_mgr = StateManager()
self.window = Window()
Clock.schedule_interval(self.update, 1.0 / 60.0)
self.game_state = GameState('lvl/levels')
self.state_mgr.push_state(self.game_state)
self.state_mgr.push_state(GameCreatorState(self))
self.event_manager = EventManager()
self.window.event_manager = self.event_manager
return self.window
def __init__(self):
pygame.init()
self.clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
self.background = pygame.surface.Surface(SCREENSIZE).convert()
self.background.fill(BLACK)
self.mousePosition = None
self.bsp = None
self.testvertexlist = []
self.segments = [
] #make global for testing so we can see them dynamically
self.events = EventManager(self)
self.player = None
self.WR3D = None
self.mode3D = False
print("SCREEN WIDTH = " + str(SCREENWIDTH))
def main():
pygame.init()
pygame.display.set_caption("The 15 Puzzle")
win = pygame.display.set_mode((WIN_WIDTH, WIN_HEIGHT))
clock = pygame.time.Clock()
event_manager = EventManager()
game_board = GameModel()
game_view = GameView(win)
spinner = CPUSpinnerController(event_manager, clock)
game_controller = GameController(game_board, game_view)
event_manager.registerListener(TickEvent(), game_controller)
event_manager.registerListener(QuitEvent(), spinner)
spinner.run()
pygame.quit()
def prepare_events(ages, bathymetries, sea_levels, thicknesses, rock_types,
rock_properties):
""" Package inputs into an EventManager instance. """
events = []
for age, bathymetry, sea_level, thickness, rock_type in zip(
ages[1:], bathymetries[1:], sea_levels[1:], thicknesses,
rock_types):
layer = Layer(present_thickness=thickness,
porosity_function=athy_porosity)
layer.set_rock_properties(rock_properties[rock_type])
event = Deposition(age=age,
bathymetry=bathymetry,
sea_level=sea_level,
layer=layer)
events.append(event)
event_manager = EventManager(initial_age=ages[0],
initial_sea_level=sea_levels[0],
initial_bathymetry=bathymetries[0])
event_manager.add_events(events)
event_manager.reconstruct_burial_history()
return event_manager
def main(screen):
grid_manager = GridManager()
player = Player(*grid_manager.random_move_through_tile())
event_manager = EventManager()
player_mover = PlayerMover(event_manager, player,
grid_manager) # noqa: F841
interaction_handler = InteractionHandler(event_manager,
grid_manager) # noqa: F841
while True:
grid_manager.print(screen)
player.print(screen)
screen.refresh()
event = screen.get_event()
if isinstance(event, KeyboardEvent):
if event.key_code == Screen.KEY_UP:
event_manager.publish(PlayerMoveEvent(PlayerMoveEvent.UP))
elif event.key_code == Screen.KEY_LEFT:
event_manager.publish(PlayerMoveEvent(PlayerMoveEvent.LEFT))
elif event.key_code == Screen.KEY_DOWN:
event_manager.publish(PlayerMoveEvent(PlayerMoveEvent.DOWN))
elif event.key_code == Screen.KEY_RIGHT:
event_manager.publish(PlayerMoveEvent(PlayerMoveEvent.RIGHT))
for seq in sequences.itervalues():
try:
seq.stop()
except:
pass
sys.exit(0)
signal.signal(signal.SIGINT, stop_threads)
for seq in sequences.itervalues():
seq.start()
current_sequence = None
pygame.display.set_mode([200, 100])
event_manager = EventManager()
while True:
for event in pygame.event.get(pygame.KEYDOWN):
event_manager.set_event("CTRL_DOWN", event.key)
for event in pygame.event.get(pygame.KEYUP):
event_manager.set_event("CTRL_UP", event.key)
evt_down = event_manager.get_event("CTRL_DOWN")
evt_up = event_manager.get_event("CTRL_UP")
if evt_down and evt_down in sequences:
print "RAISE CTRL_DOWN", evt_down
current_sequence = sequences[evt_down]
current_sequence.play()
if evt_up and evt_up in sequences:
#! /usr/bin/env python # -*- coding: utf-8 -*- # Copyright (C) 2011 ~ 2012 Deepin, Inc. # 2011 ~ 2012 Hou Shaohui # # Author: Hou Shaohui <*****@*****.**> # Maintainer: Hou Shaohui <*****@*****.**> # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from events import EventManager event_manager = EventManager(use_logger=False)
from events import EventManager
from host import Host
from link import Link
from flow import Flow
from packet import Packet, DATA_PACKET_SIZE, CONTROL_PACKET_SIZE
class PacketRecorder:
def __init__(self, next_component):
self.next_component = next_component
self.packets = []
def on_reception(self, t, p):
self.packets.append(p)
self.next_component.on_reception(t, p)
em = EventManager(logging=False)
host_1 = Host(em, 'H1', debug=True)
p1 = PacketRecorder(host_1)
host_2 = Host(em, 'H2', debug=True)
p2 = PacketRecorder(host_2)
l1_a = Link(em, 'L1_a', host_1, p2, 10485760, 0.01, 524288, debug=False)
l1_b = Link(em, 'L1_b', host_2, p1, 10485760, 0.01, 524288, debug=False)
host_1.link = l1_a
host_2.link = l1_b
flow = Flow(em, 'F1', host_1, host_2, DATA_PACKET_SIZE, 1, StopAndWait(), debug=True)
em.run()
# Packets sent by host 1
p2_expect = [
# SYN
Packet('F11', flow, host_1, host_2, syn_flag = True, ack_flag = False,
from events import EventManager
from file_input import read_network
from io import StringIO
from contextlib import redirect_stdout
if __name__ == '__main__':
em = EventManager()
read_network('test_case_1_reno.json', em)
em.run()
print(em.current_time)
#!/usr/bin/env python #-*- coding:utf-8 -*- # Copyright (C) 2011 ~ 2013 Deepin, Inc. # 2011 ~ 2013 Zeng Zhi # # Author: Zeng Zhi <*****@*****.**> # Maintainer: Zeng Zhi <*****@*****.**> # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. #import gobject from events import EventManager nm_events = EventManager(use_logger=False) #print nm_events, "-lib"
