class Rocket_Game():
''' simple rocket on screen that can move up down left right '''
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.screen_width = self.screen.get_rect().width
self.screen_height = self.screen.get_rect().height
self.settings = Settings()
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
self.bg_color = self.settings.bg_color
self.ship = Rocket(self)
def run_game(self):
'''Start main loop for game'''
while True:
self._check_events()
self.ship.update()
self._update_screen()
def _update_screen(self):
self.screen.fill(self.bg_color)
self.ship.blitme()
# Make most recently drawn screen visible
pygame.display.flip()
def _check_events(self):
# Watch for events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._self_check_key_down(event)
elif event.type == pygame.KEYUP:
self._self_check_key_up(event)
def _self_check_key_down(self, event):
''' Checks key down events '''
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_UP:
self.ship.moving_up = True
elif event.key == pygame.K_DOWN:
self.ship.moving_down = True
elif event.key == pygame.K_q:
sys.exit()
def _self_check_key_up(self, event):
''' Checks the key up events '''
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
elif event.key == pygame.K_UP:
self.ship.moving_up = False
elif event.key == pygame.K_DOWN:
self.ship.moving_down = False
def __init__(self):
# Config
self.tps_max = 100.0
# Initialisation
pygame.init()
self.resolution = (1024, 600)
self.screen = pygame.display.set_mode(self.resolution)
self.tps_clock = pygame.time.Clock()
self.tps_delta = 0.0
self.player = Rocket(self)
self.circles = [Circle(self, self.player)]
while True:
# Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
# Ticking
self.tps_delta += self.tps_clock.tick() / 1000.0
while self.tps_delta > 1 / self.tps_max:
self.tick()
self.tps_delta -= 1 / self.tps_max
# Drawing
self.screen.fill((0, 0, 0))
self.draw()
pygame.display.flip()
def __init__(self):
pygame.init()
self.tps_delta = 0.0
self.tps_clock = pygame.time.Clock()
self.player = Rocket()
self.enemies = EnemyCollection(self.player.points)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
self.player.fire_bullet()
self.tps_delta += self.tps_clock.tick() / 1000.0
while self.tps_delta > 1 / Settings.MAX_TPS:
self.tick()
self.tps_delta -= 1 / Settings.MAX_TPS
Settings.SCREEN.fill((0, 0, 0))
self.draw()
pygame.display.flip()
def run():
global rocket
#affichage
model1 = pygame.image.load('Model/sma.gif').convert()
model2 = pygame.image.load('Model/med.gif').convert()
model3 = pygame.image.load('Model/big.gif').convert()
modelcanon = pygame.image.load("Model/canon.png").convert()
alien.afficher(core.screen, model1, model2, model3, xalien)
if rocket != None:
rocket.afficher(core.screen, None)
canon.Apparaitre(core.screen, modelcanon)
#clavier
keys = pygame.key.get_pressed()
if keys[pygame.K_SPACE]:
if rocket == None:
rocket = Rocket()
rocket.position.x = canon.position.x + 14
rocket.position.y = canon.position.y
if keys[pygame.K_RIGHT]:
canon.position.x = canon.position.x + 10 if canon.position.x < 720 else 720
if keys[pygame.K_LEFT]:
canon.position.x = canon.position.x - 10 if canon.position.x > 50 else 50
#deplacement
if rocket != None:
rocket.deplacement()
if rocket.position.y < 0:
rocket = None
alien.checkCollision()
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
# Get game's settings
self.settings = Settings()
# Create a main display
self.screen = pygame.display.set_mode((1200, 800))
# Set a main display's name
pygame.display.set_caption("Space Battle")
# Create an instance to store game statistics
self.stats = GameStats(self)
# Create a scoreboard
self.scoreboard = Scoreboard(self)
# Create a rocket
self.rocket = Rocket(self)
# Create a list of bullets
self.bullets = pygame.sprite.Group()
# Create a fleet of spaceships
self.spaceships = pygame.sprite.Group()
self._create_fleet()
# Make the Start button.
self.start_button = PlayButton(self, "Start")
def game_function():
"""Main function to initialize Space Invaders game."""
pygame.init()
game_para = Parameters()
# Game screen properties.
screen = pygame.display.set_mode(
(game_para.screen_width, game_para.screen_height))
pygame.display.set_caption('Space Invaders')
# Make a rocket.
rocket = Rocket(screen)
# Make a group of an aliens.
aliens = Group()
# Make a group where all fired missiles will be stored.
missiles = Group()
# Create a row of an aliens.
gm.alien_army(game_para, screen, aliens, rocket)
# Main loop of the Space Invaders game.
while True:
# Call for game event function.
gm.event_type(game_para, rocket, screen, missiles)
# Instance for Rocket smooth movement.
rocket.new_position()
# Call for missiles add and remove function.
gm.missile_management(missiles, aliens)
# Call for alien update function.
gm.alien_new_position(game_para, aliens)
# Call for the screen renew function.
gm.screen_renew(screen, rocket, game_para, missiles, aliens)
def run_game():
pygame.init()
screen = pygame.display.set_mode((800, 400))
pygame.display.set_caption('Rocket Fire!!!')
bg_color = (66, 106, 175)
screen.fill(bg_color)
rocket = Rocket(screen)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
rocket.moving_up = True
elif event.key == pygame.K_DOWN:
rocket.moving_down = True
elif event.type == pygame.KEYUP:
if event.key == pygame.K_UP:
rocket.moving_up = False
elif event.key == pygame.K_DOWN:
rocket.moving_down = False
rocket.update()
rocket.blitme()
pygame.display.flip()
def __init__(self,
windowX: int,
windowY: int,
width=120,
height=30,
isNew=False,
isMoving=False,
imagePath='images/floor.png'):
super().__init__(imagePath, windowX, windowY, width, height)
self.__isMoving = isMoving # 地板是否左右移动
currHeight = Floor.lastHeight + randint(70, 90)
self._rect.x = randint(0, windowX - width)
self._rect.y = 50 if isNew else windowY - currHeight
Floor.lastHeight = currHeight
# 板子上面的东西：火箭 弹簧 怪物 等...
self.__itemOn = None
if randint(0, 100) < 20:
self.__itemOn = Spring(windowX, windowY)
self.__itemOn.attachTo(self)
if randint(0, 100) < 20:
self.__itemOn = Rocket(windowX, windowY, self.getLeft(),
self.getTop())
self.__itemOn.attachTo(self)
def activate(self):
if not self.config:
self.log.info('Webserver is not configured. Forbid activation')
return
host = self.config['HOST']
port = self.config['PORT']
ssl = self.config['SSL']
interfaces = [(host, port)]
if ssl['enabled']:
# noinspection PyTypeChecker
interfaces.append(
(ssl['host'], ssl['port'], ssl['key'], ssl['certificate']))
self.log.info('Firing up the Rocket')
from errbot.bootstrap import sentry_client
if sentry_client is None:
wsgi_app = bottle_app
else:
from raven.contrib.bottle import Sentry
bottle_app.catchall = False
wsgi_app = Sentry(bottle_app, sentry_client)
self.webserver = Rocket(
interfaces=interfaces,
app_info={'wsgi_app': wsgi_app},
)
self.webserver.start(background=True)
self.log.debug('Liftoff!')
super().activate()
def __init__(self, width=640, height=480):
# config
self.tps_max = 100.0
self.width = width
self.height = height
# initialization
pygame.init()
self.screen = pygame.display.set_mode((self.width, self.height))
self.tps_clock = pygame.time.Clock()
self.tps_delta = 0.0
self.player = Rocket(self.screen)
breaky = False
while True:
# handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type is pygame.KEYDOWN and event.key is pygame.K_ESCAPE:
breaky = True
if breaky: break
self.tps_delta += self.tps_clock.tick(50) / 1000.0
while self.tps_delta > 1 / self.tps_max:
self.tick()
self.tps_delta -= 1 / self.tps_max
# drawing
self.screen.fill((0, 0, 0))
self.draw()
pygame.display.flip()
def start(self):
self.p1 = Rocket(self.width / 2 - 250, self.height / 2, (255, 0, 0))
self.p2 = Rocket(self.width / 2 + 250, self.height / 2, (0, 0, 255))
self.p2.heading = 180
self.p2.drift_heading = 180
self.levels = [(Wall(5, 5, 1, self.height), Wall(5, 5, self.width, 1),
Wall(self.width - 5, 5, 1, self.height),
Wall(5, self.height - 5, self.width,
1), Wall(100, 100, 300,
135), Wall(900, 450, 150, 250)),
(Wall(5, 5, 1, self.height / 2 - 150),
Wall(5, self.height / 2 + 150, 1,
self.height / 2 - 150), Wall(5, 5, self.width, 1),
Wall(self.width - 5, 5, 1, self.height / 2 - 150),
Wall(self.width - 5, self.height / 2 + 150, 1,
self.height / 2 - 150),
Wall(5, self.height - 5, self.width, 1))]
self.current_level = randint(0, len(self.levels) - 1)
self.powerup_ids = [
"none", # id = 0
"scatter_shot", # id = 1
"missile" # id = 2
]
self.powerups = []
self.powerup_spawn_timer = 0
def _next_gen(self):
fitness_list = []
new_generation = []
for member in self.population:
fitness = (member.fitness(self.target_location)) * 1000
fitness_list.append((fitness,member))
new_list = sorted(fitness_list, key=lambda rkt: rkt[0])
child1,child2 = new_list[len(new_list)-1][1].crossover(new_list[len(new_list)-2][1])
child1.mutate(self.mutation_rate)
child2.mutate(self.mutation_rate)
for member in self.population:
if ((member.fitness(self.target_location)) * 1000) == new_list[0][0] :
new_generation.append(child1)
elif ((member.fitness(self.target_location)) * 1000) == new_list[1][0] :
new_generation.append(child2)
else :
temp = Rocket(FPS)
temp.forces = member.forces
new_generation.append(temp)
self.population = []
self.population = new_generation
self.best_child = new_list[len(new_list)-1][1]
class Game(object):
def __init__(self):
#config
self.fps_max = 100.0
#initialization
pygame.init()
self.screen = pygame.display.set_mode((1280, 720))
self.fpsclock = pygame.time.Clock()
self.fps_delta = 0.0
self.player = Rocket(self)
while True:
# take events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
sys.exit(0)
# ticking
self.fps_delta += self.fpsclock.tick() / 1000.0
while self.fps_delta > self.fps_max:
self.tick()
self.fps_delta -= self.fps_max
#rendering
self.screen.fill((0, 0, 0))
self.draw()
pygame.display.flip()
def tick(self):
self.player.tick()
def draw(self):
self.player.draw()
def __init__(self):
# Configuration
self.tps_max = 100.0
# Initialization
pygame.init()
self.screen = pygame.display.set_mode((1280, 720))
self.tps_clock = pygame.time.Clock()
self.tps_delta = 0.0
self.player = Rocket(self)
while True:
# Handling events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
sys.exit(0)
# Ticking
self.tps_delta += self.tps_clock.tick() / 1000.0
while self.tps_delta > 1 / self.tps_max:
self.tick()
self.tps_delta -= 1 / self.tps_max
# Drawing
self.screen.fill((0, 0, 0))
self.draw()
pygame.display.flip()
def __init__(self, **kwargs):
"""Initialize the rocket timer using values from settings"""
config = getattr(settings, 'ROCKET', None)
if config is None:
config = {}
self.mode = config.get('mode') or 'editor'
self.files = config.get('files') or './tracks'
self.project = config.get('project') or 'project.xml'
self.start_paused = False
self.controller = TimeController(config.get('rps', 24))
if self.mode == 'editor':
self.rocket = Rocket.from_socket(self.controller,
track_path=self.files)
self.start_paused = True
elif self.mode == 'project':
self.rocket = Rocket.from_project_file(self.controller,
self.project)
elif self.mode == 'files':
self.rocket = Rocket.from_files(self.controller, self.files)
else:
raise ValueError("Unknown rocket mode: '{}'".format(self.mode))
# Register tracks in the editor
# Ninja in pre-created track objects
for track in tracks.tacks:
self.rocket.tracks.add(track)
# Tell the editor about these tracks
for track in tracks.tacks:
self.rocket.track(track.name)
self.rocket.update()
super().__init__(**kwargs)
def __init__(self):
# Config
self.tps_max = 25.0
#Initialization
pygame.init()
self.screen = pygame.display.set_mode((1280, 720))
icon = pygame.image.load("rocket.png")
pygame.display.set_caption("Space rocket")
pygame.display.set_icon(icon)
self.tps_clock = pygame.time.Clock()
self.tps_delta = 0.0
self.player = Rocket(self)
while True:
# Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
sys.exit(0)
# Ticking
self.tps_delta += self.tps_clock.tick(
) / 1000 # dt - to czas ms miedzy klatkami
while self.tps_delta > 1 / self.tps_max:
self.tick()
self.tps_delta -= 1 / self.tps_max
# Drawing
self.screen.fill((0, 0, 0))
self.draw()
pygame.display.flip()
def __init__(self):
max_fps = 100
screen_width = 1280
screen_high = 720
# INITIALIZATION
pygame.init()
self.screen = pygame.display.set_mode((screen_width, screen_high))
self.fps_clock = pygame.time.Clock()
self.fps_delta = 0.0
self.player = Rocket(self)
while True:
# HANDLE EVENTS
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
sys.exit(0)
# TICKING
self.fps_delta += self.fps_clock.tick() / 1000.0
while self.fps_delta > 1 / max_fps:
self.tick()
self.fps_delta -= 1 / max_fps
# DRAWING
self.screen.fill((0, 0, 0))
self.draw()
pygame.display.flip()
def __init__(self,
size=10,
life_time=60,
origin=None,
target=None,
prev_child=None):
if origin is None:
origin = [300, 500]
if target is None:
target = [300, 100]
self.origin = origin
self.prev_child = prev_child
self.mutation_rate = 0.05
self.average_fitness = 0
self.highest_average_fitness = 1
self.fitness_graph = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.size = size
self.life_time = life_time
self.target = Vector(target[0], target[1])
self.best_child = Rocket(self.life_time)
self.members = []
for member in range(0, self.size):
self.members.append(
Rocket(self.life_time,
origin=self.origin,
prev_genes=self.prev_child))
def __init__(self):
# config
self.max_tps = 300.0
self.tps_delta = 0.0
self.width = 1280
self.height = 720
# initialization
pygame.init()
self.screen = pygame.display.set_mode((self.width, self.height))
self.tps_clock = pygame.time.Clock()
# player
self.player = Rocket(self)
while True:
# handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
sys.exit(0)
# ticking
self.tps_delta += self.tps_clock.tick() / 1000.0
while self.tps_delta > 1 / self.max_tps:
self.tick() # run 300 ticks per second
self.tps_delta -= 1 / self.max_tps
# drawing
self.screen.fill((0, 0, 0)) # clear the screen
self.draw()
pygame.display.flip()
class RocketGame:
"""Overall class to manage game assets and behavior."""
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Rocket Game")
self.rocket = Rocket(self)
def run_game(self):
"""Start the main loop for the game."""
while True:
self._check_events()
self.rocket.update()
self._update_screen()
def _check_events(self):
"""Respond to keypresses and mouse events."""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
def _check_keydown_events(self, event):
"""Respond to keypresses."""
if event.key == pygame.K_RIGHT:
self.rocket.moving_right = True
elif event.key == pygame.K_LEFT:
self.rocket.moving_left = True
if event.key == pygame.K_UP:
self.rocket.moving_up = True
elif event.key == pygame.K_DOWN:
self.rocket.moving_down = True
elif event.key == pygame.K_q:
sys.exit()
def _check_keyup_events(self, event):
"""Respond to key releases."""
if event.key == pygame.K_RIGHT:
self.rocket.moving_right = False
elif event.key == pygame.K_LEFT:
self.rocket.moving_left = False
if event.key == pygame.K_UP:
self.rocket.moving_up = False
elif event.key == pygame.K_DOWN:
self.rocket.moving_down = False
def _update_screen(self):
"""Update images on the screen, and flip to the new screen."""
self.screen.fill(self.settings.bg_color)
self.rocket.blitme()
pygame.display.flip()
def run_game():
"""Initialize game."""
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((
ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Domination")
rocket = Rocket(screen)
# Start the main loop for the game.
while True:
# Watch for keyboard and mouse events.
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
# Redraw the screen during each pass through the loop.
screen.fill(ai_settings.bg_color)
rocket.blitme()
# Make the most recently drawn screen visible.
pygame.display.flip()
def run_server():
log = logging.getLogger('Rocket')
log.setLevel(logging.INFO)
log.addHandler(logging.StreamHandler(sys.stdout))
server = Rocket(interfaces=('0.0.0.0', 5000),
method='wsgi',
app_info={"wsgi_app": app})
server.start()
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Flying a Rocket East West South and North")
self.bg_color = self.settings.bgcolor
self.rocket = Rocket(self)
def shoot_rockets(self):
rocket = Rocket(random.randrange(50, WIDTH - 200), -75,
self.rocket_img)
rocket1 = Rocket(random.randrange(50, WIDTH - 200), -75,
self.rocket_img)
self.rockets.append(rocket)
self.rockets.append(rocket1)
def run(self):
self.setupRoutes()
self.logger.debug('Flask Server Starting')
self.server = Rocket((self.host, self.port), 'wsgi',
{"wsgi_app": self.app})
self.server.start(background=False)
#self.app.run(host=self.host, port=self.port)
self.logger.debug('Flask Server Stopping')
def main():
rocket = Rocket(True)
simulator = Simulator()
while not simulator.done():
simulator.update(rocket.get_thrust())
rocket.update(simulator.get_sim_sensors())
print(f'Thrust: {rocket.get_thrust()}')
def __init__(self):
pygame.init()
self.setting = RocketSettings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
pygame.display.set_caption("Rocket Game")
self.rocket = Rocket(self)
def __init__(self):
"""Initialize the game and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
self.screen_bottom = self.screen.get_rect().bottom
self.bg_color = self.settings.bg_color
pygame.display.set_caption("Lander")
# Create and instance to store game stats
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.rocket = Rocket(self, 1)
self.rocket2 = Rocket(self, 2)
self.rocket2.rect.top = self.screen_bottom
self.flames = Flames(self)
self.terrain_group = pygame.sprite.Group()
self._create_terrain_group()
self.pad = Pad(self)
# Make the Play button
self.play_button = Button(self, "Start", 500, 500)
# Make the info button
self.info_button = InfoButton(self, "Instructions", 500, 600)
# Set the high score file
self.filename = "highscore.txt"
# Make a banner of instructions
self.banner = Banner(self, "Click on 'Start' or press 's'", 350, 100)
self.banner2 = Banner(self, "Press 'q' to Quit", 350, 200)
self.show_instructions = Banner(
self, "Use up arrow for thrust and left/right arrows to rotate.",
300, 650)
self.show_instructions2 = Banner(
self, "Land on the platform with parameters green. "
"Bonus points for fuel remaining", 300, 700)
self.info_displayed = False
# Make a bonus points banner
bonus_points_str = "place holder"
self.banner3 = Banner(self, bonus_points_str, 500, 200)
# Get sound file:
self.explosion_sound = pygame.mixer.Sound("explosion.wav")
self.thrust_sound = pygame.mixer.Sound("thrusters.wav")
self.applause_sound = pygame.mixer.Sound("applause.wav")
self.alert_sound = pygame.mixer.Sound("alert.wav")
pygame.mixer.music.load('lander.wav')
pygame.mixer.music.set_volume(1.0)
def run_game():
pygame.display.init()
def_set = Set()
screen = pygame.display.set_mode((def_set.width, def_set.height))
pygame.display.set_caption('Rocket')
rocket = Rocket(def_set, screen)
while True:
rocket_function.check_rocket_event(rocket)
rocket.moving()
rocket_function.update_rocket_screen(def_set, rocket, screen)
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(self.settings.scr_sz)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self.rocket = Rocket(self)
pygame.display.set_caption("Sideways Shooter")
self._create_fleet()
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Rocket Game")
self.rocket = Rocket(self)
def run_server():
# Setup logging
log = logging.getLogger('Rocket')
log.setLevel(logging.INFO)
log.addHandler(logging.StreamHandler(sys.stdout))
# Set the configuration of the web server
server = Rocket(interfaces=('0.0.0.0', 5000), method='wsgi',
app_info={"wsgi_app": app})
# Start the Rocket web server
server.start()
def start(self):
"""Starts the Bottle server."""
rocket = Rocket((self._address, self._port), 'wsgi', {'wsgi_app': self._app})
server_thread = Thread(target=rocket.start, name='_rocket')
server_thread.start()
try:
while server_thread.is_alive():
server_thread.join(5)
except (KeyboardInterrupt, SystemExit):
self._helper.poll.stop = True
rocket.stop()
def rocket_http(debug=False):
# Setup logging
log = logging.getLogger('Rocket')
log.setLevel(logging.INFO)
if debug:
log.addHandler(logging.StreamHandler(sys.stdout))
else:
log.addHandler(logging.FileHandler('http.log'))
# Set the configuration of the web server
server = Rocket(interfaces=('0.0.0.0', 8010, 'ssl/server.key', 'ssl/server.crt'), method='wsgi', app_info={"wsgi_app": app})
server.start(background=True)
def start():
log = logging.getLogger('Rocket')
log.addHandler(logging.FileHandler('server.log'))
session_opts = {
'session.data_dir' : '/tmp/fmk/data',
'session.lock_dir' : '/tmp/fmk/lock',
'session.type' : 'redis',
'session.url' : '127.0.0.1:6379?db=3'
}
app = Dispatcher(mapfile='rest.map', wrap=Request)
app = Session(app, session_opts)
server = Server(
interfaces=('127.0.0.1', 9000),
method='wsgi',
app_info=dict(wsgi_app=app),
min_threads=64,
max_threads=128,
timeout=60
)
try:
print 'starting wsgi server...'
server.start()
except KeyboardInterrupt:
server.stop()
except Exception as e:
print type(e)
print e.args, e
server.stop()
def run_webserver(self):
#noinspection PyBroadException
try:
host = self.config['HOST']
port = self.config['PORT']
ssl = self.config['SSL']
interfaces = [(host, port)]
if ssl['enabled']:
interfaces.append((ssl['host'], ssl['port'], ssl['key'], ssl['certificate']))
logging.info('Firing up the Rocket')
rocket = Rocket(interfaces=interfaces,
app_info={'wsgi_app': bottle_app}, )
rocket.start()
logging.debug('Rocket has landed')
except KeyboardInterrupt as _:
logging.exception('Keyboard interrupt, request a global shutdown.')
holder.bot.shutdown()
except Exception as _:
logging.exception('The Rocket has exploded.')
self.warn_admins("There's an issue with the Rocket: %s" % _)
def run_game():
#Initialize and create screen project
pygame.init()
game_settings = Settings()
# screen = pygame.display.set_mode((1200,800))
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption("Rocket game")
# make a rocket
rocket = Rocket(game_settings, screen)
# Make a group to store bullets in.
bullets = Group()
aliens = Group()
fn.create_fleet(game_settings, screen, rocket, aliens)
# Main loop
while True:
# Watch for keyboard and mouse events
fn.check_events(game_settings, screen, rocket, bullets)
rocket.update()
fn.update_bullets(bullets)
fn.update_screen(game_settings, screen, rocket, aliens, bullets)
def activate(self):
if not self.config:
self.log.info('Webserver is not configured. Forbid activation')
return
host = self.config['HOST']
port = self.config['PORT']
ssl = self.config['SSL']
interfaces = [(host, port)]
if ssl['enabled']:
# noinspection PyTypeChecker
interfaces.append((ssl['host'], ssl['port'], ssl['key'], ssl['certificate']))
self.log.info('Firing up the Rocket')
self.webserver = Rocket(interfaces=interfaces,
app_info={'wsgi_app': bottle_app}, )
self.webserver.start(background=True)
self.log.debug('Liftoff!')
super().activate()
def setUp(self):
global SERVER_PORT_START
SERVER_PORT_START += 1
self.starttuple = ('127.0.0.1', SERVER_PORT_START)
#log = logging.getLogger('Rocket')
#log.setLevel(logging.DEBUG)
#fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s')
#h = logging.StreamHandler()
#h.setFormatter(fmt)
#log.addHandler(h)
self.server = Rocket(self.starttuple,
"fs",
min_threads=0)
self.server.start(background=True)
# Create a socket connecting to listener's port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(SOCKET_TIMEOUT)
self.sock.connect(self.starttuple)
response = r.read()
if response == 'ON':
state = '1'
else:
state = '0'
else:
state = msg.payload
client.publish(PREFIX + '{}_Relay_{}'.format(controller, relay), state)
if __name__ == '__main__':
log = logging.getLogger('Rocket')
log.setLevel(logging.INFO)
fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s')
h = logging.FileHandler('/var/log/wb-ab-log-eth.log')
h.setFormatter(fmt)
log.addHandler(h)
mqttc.on_connect = on_connect
mqttc.on_message = on_message
mqttc.connect("localhost", 1883)
server = Rocket(interfaces=('0.0.0.0', 9999),
method='wsgi',
app_info={"wsgi_app":ab_log_app})
mqttc.loop_start()
server.start()
mqttc.loop_stop()
mqttc.disconnect()
from bottle import Bottle, request, response
from rocket import Rocket
my_argparser = argparse.ArgumentParser()
my_argparser.add_argument( '--listen-on-ip', '-l', required=True )
my_argparser.add_argument( '--listen-on-port', '-p', type=int, required=True )
my_argparser.add_argument( '--ssl-key', required=True )
my_argparser.add_argument( '--ssl-cert', required=True )
my_argparser.add_argument( '--verbose', action='store_true')
parsedargs = my_argparser.parse_args()
my_example_app = Bottle( )
# A global handler that runs for all requests
@my_example_app.hook('before_request')
def before_request():
response.set_header('X-Rocket-Powered', socket.getfqdn())
# Let people test to see if we are alive
@my_example_app.route('/ping')
def hello():
return "pong"
#Enable INFO logging?
if parsedargs.verbose:
log = logging.getLogger('Rocket')
log.setLevel( logging.INFO )
log.addHandler(logging.StreamHandler())
#Let's go
my_rocket = Rocket( ( parsedargs.listen_on_ip, parsedargs.listen_on_port, parsedargs.ssl_key, parsedargs.ssl_cert ), 'wsgi', { "wsgi_app":my_example_app } )
my_rocket.start()
class Webserver(BotPlugin):
min_err_version = VERSION # don't copy paste that for your plugin, it is just because it is a bundled plugin !
max_err_version = VERSION
def __init__(self):
self.webserver = None
self.webchat_mode = False
self.ssl_context = None
self.test_app = TestApp(bottle_app)
super(Webserver, self).__init__()
def get_configuration_template(self):
return {'HOST': '0.0.0.0',
'PORT': 3141,
'SSL': {'enabled': False,
'host': '0.0.0.0',
'port': 3142,
'certificate': "",
'key': ""}}
def check_configuration(self, configuration):
# it is a pain, just assume a default config if SSL is absent or set to None
if configuration.get('SSL', None) is None:
configuration['SSL'] = {'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': ""}
super(Webserver, self).check_configuration(configuration)
def activate(self):
if not self.config:
logging.info('Webserver is not configured. Forbid activation')
return
host = self.config['HOST']
port = self.config['PORT']
ssl = self.config['SSL']
interfaces = [(host, port)]
if ssl['enabled']:
interfaces.append((ssl['host'], ssl['port'], ssl['key'], ssl['certificate']))
logging.info('Firing up the Rocket')
self.webserver = Rocket(interfaces=interfaces,
app_info={'wsgi_app': bottle_app}, )
self.webserver.start(background=True)
logging.debug('Liftoff!')
super(Webserver, self).activate()
logging.info('Webserver activated')
def deactivate(self):
if self.webserver is not None:
logging.debug('Sending signal to stop the webserver')
self.webserver.stop()
super(Webserver, self).deactivate()
#noinspection PyUnusedLocal
@botcmd(template='webstatus')
def webstatus(self, mess, args):
"""
Gives a quick status of what is mapped in the internal webserver
"""
return {'rules': (((route.rule, route.name) for route in bottle_app.routes))}
@webhook
def echo(self, incoming_request):
"""
A simple test webhook
"""
logging.debug("Your incoming request is :" + str(incoming_request))
return str(incoming_request)
@botcmd(split_args_with=' ')
def webhook_test(self, _, args):
"""
Test your webhooks from within err.
The syntax is :
!webhook test [relative_url] [post content]
It triggers the notification and generate also a little test report.
"""
url = args[0] if PY3 else args[0].encode() # PY2 needs a str not unicode
content = ' '.join(args[1:])
# try to guess the content-type of what has been passed
try:
# try if it is plain json
loads(content)
contenttype = 'application/json'
except ValueError:
# try if it is a form
splitted = content.split('=')
#noinspection PyBroadException
try:
payload = '='.join(splitted[1:])
loads(unquote(payload))
contenttype = 'application/x-www-form-urlencoded'
except Exception as _:
contenttype = 'text/plain' # dunno what it is
logging.debug('Detected your post as : %s' % contenttype)
response = self.test_app.post(url, params=content, content_type=contenttype)
return TEST_REPORT % (url, contenttype, response.status_code)
def run(self, handler):
from rocket import Rocket
server = Rocket((self.host, self.port), 'wsgi', { 'wsgi_app' : handler })
server.start()
class ConnectionTest(unittest.TestCase):
def setUp(self):
global SERVER_PORT_START
SERVER_PORT_START += 1
self.starttuple = ('127.0.0.1', SERVER_PORT_START)
#log = logging.getLogger('Rocket')
#log.setLevel(logging.DEBUG)
#fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s')
#h = logging.StreamHandler()
#h.setFormatter(fmt)
#log.addHandler(h)
self.server = Rocket(self.starttuple,
"fs",
min_threads=0)
self.server.start(background=True)
# Create a socket connecting to listener's port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(SOCKET_TIMEOUT)
self.sock.connect(self.starttuple)
def tearDown(self):
self.sock.close()
self.server.stop()
def testMembers(self):
c = connection.Connection(*(self.server.active_queue.get(timeout=10)))
members = ["close", "client_addr", "server_port", "ssl", "socket", "start_time"]
for m in members:
self.assertTrue(hasattr(c, m),
msg="Connection object does not have %s " % m)
def testSocketTimeout(self):
c = connection.Connection(*(self.server.active_queue.get(timeout=10)))
timeout = c.socket.gettimeout()
self.assertEqual(timeout, SOCKET_TIMEOUT)
def testSocketRecv(self):
c = connection.Connection(*(self.server.active_queue.get(timeout=10)))
SENT_DATA = b("this is a test")
self.sock.send(SENT_DATA)
data = c.recv(len(SENT_DATA))
self.assertEqual(data, SENT_DATA)
def testSocketSend(self):
c = connection.Connection(*(self.server.active_queue.get(timeout=10)))
RECVD_DATA = b("this is a test")
c.send(RECVD_DATA)
data = self.sock.recv(len(RECVD_DATA))
self.assertEqual(data, RECVD_DATA)
def testFileLikeSocketRead(self):
c = connection.Connection(*(self.server.active_queue.get(timeout=10)))
SENT_DATA = b("this is a test")
self.sock.send(SENT_DATA)
f = c.makefile()
data = b(f.read(len(SENT_DATA)))
self.assertEqual(data, SENT_DATA)
f.close()
def testFileLikeSocketReadline(self):
c = connection.Connection(*(self.server.active_queue.get(timeout=10)))
SENT_DATA = b("""this is a test\nthis is another line\n""")
self.sock.send(SENT_DATA)
time.sleep(0.25)
f = c.makefile()
try:
for l in SENT_DATA.splitlines():
data = b(f.readline())
self.assertEqual(data, l+b("\n"))
finally:
f.close()
c.close()
def testFileLikeSocketReadlines(self):
c = connection.Connection(*(self.server.active_queue.get(timeout=10)))
SENT_DATA = b("""this is a test\nthis is another line\n""")
self.sock.send(SENT_DATA)
self.sock.close()
time.sleep(0.25)
f = c.makefile()
sent_lines = [x + b('\n') for x in SENT_DATA.splitlines()]
data_lines = [b(x) for x in f.readlines()]
self.assertEqual(sent_lines, data_lines)
f.close()
c.close()
class Webserver(BotPlugin):
def __init__(self, *args, **kwargs):
self.webserver = None
self.webchat_mode = False
self.ssl_context = None
self.test_app = TestApp(bottle_app)
super().__init__(*args, **kwargs)
def get_configuration_template(self):
return {'HOST': '0.0.0.0',
'PORT': 3141,
'SSL': {'enabled': False,
'host': '0.0.0.0',
'port': 3142,
'certificate': "",
'key': ""}}
def check_configuration(self, configuration):
# it is a pain, just assume a default config if SSL is absent or set to None
if configuration.get('SSL', None) is None:
configuration['SSL'] = {'enabled': False, 'host': '0.0.0.0', 'port': 3142, 'certificate': "", 'key': ""}
super().check_configuration(configuration)
def activate(self):
if not self.config:
self.log.info('Webserver is not configured. Forbid activation')
return
host = self.config['HOST']
port = self.config['PORT']
ssl = self.config['SSL']
interfaces = [(host, port)]
if ssl['enabled']:
# noinspection PyTypeChecker
interfaces.append((ssl['host'], ssl['port'], ssl['key'], ssl['certificate']))
self.log.info('Firing up the Rocket')
self.webserver = Rocket(interfaces=interfaces,
app_info={'wsgi_app': bottle_app}, )
self.webserver.start(background=True)
self.log.debug('Liftoff!')
super().activate()
def deactivate(self):
if self.webserver is not None:
self.log.debug('Sending signal to stop the webserver')
self.webserver.stop()
super().deactivate()
# noinspection PyUnusedLocal
@botcmd(template='webstatus')
def webstatus(self, mess, args):
"""
Gives a quick status of what is mapped in the internal webserver
"""
return {'rules': (((route.rule, route.name) for route in bottle_app.routes))}
@webhook
def echo(self, incoming_request):
"""
A simple test webhook
"""
self.log.debug("Your incoming request is :" + str(incoming_request))
return str(incoming_request)
@botcmd(split_args_with=' ')
def webhook_test(self, _, args):
"""
Test your webhooks from within err.
The syntax is :
!webhook test [relative_url] [post content]
It triggers the notification and generate also a little test report.
"""
url = args[0]
content = ' '.join(args[1:])
# try to guess the content-type of what has been passed
try:
# try if it is plain json
loads(content)
contenttype = 'application/json'
except ValueError:
# try if it is a form
splitted = content.split('=')
# noinspection PyBroadException
try:
payload = '='.join(splitted[1:])
loads(unquote(payload))
contenttype = 'application/x-www-form-urlencoded'
except Exception as _:
contenttype = 'text/plain' # dunno what it is
self.log.debug('Detected your post as : %s' % contenttype)
response = self.test_app.post(url, params=content, content_type=contenttype)
return TEST_REPORT % (url, contenttype, response.status_code)
@botcmd(admin_only=True)
def generate_certificate(self, mess, args):
"""
Generate a self-signed SSL certificate for the Webserver
"""
if not has_crypto:
yield ("It looks like pyOpenSSL isn't installed. Please install this "
"package using for example `pip install pyOpenSSL`, then try again")
return
yield ("Generating a new private key and certificate. This could take a "
"while if your system is slow or low on entropy")
key_path = os.sep.join((self.bot_config.BOT_DATA_DIR, "webserver_key.pem"))
cert_path = os.sep.join((self.bot_config.BOT_DATA_DIR, "webserver_certificate.pem"))
make_ssl_certificate(key_path=key_path, cert_path=cert_path)
yield "Certificate successfully generated and saved in {}".format(self.bot_config.BOT_DATA_DIR)
suggested_config = self.config
suggested_config['SSL']['enabled'] = True
suggested_config['SSL']['host'] = suggested_config['HOST']
suggested_config['SSL']['port'] = suggested_config['PORT'] + 1
suggested_config['SSL']['key'] = key_path
suggested_config['SSL']['certificate'] = cert_path
yield ("To enable SSL with this certificate, the following config "
"is recommended:")
yield "{!r}".format(suggested_config)
teaching WSGI concepts."""
(valuetype, value) = ("sz", params[key])
fullpath = base + "\\" + key
(path, keyname) = fullpath.rsplit("\\", 1)
if keyname == "@" or keyname == "":
keyname = None
registry_set(root, path, keyname, value, type=datatypes[valuetype])
if __name__ == "__main__":
if len(sys.argv) > 1 and sys.argv[1] == "doctest":
import doctest
sys.exit(doctest.testmod())
if len(sys.argv) > 1 and sys.argv[1] == "install":
install_windows_service()
sys.exit(0)
debug = False
if debug == True:
app.run(host="0.0.0.0", port=30880, debug=True)
else:
port = 8080
server = Rocket(("0.0.0.0", port), "wsgi", {"wsgi_app": app})
try:
logger.info("starting waptserver")
server.start()
except KeyboardInterrupt:
logger.info("stopping waptserver")
server.stop()
app.processing_th = Processing(app.pre_queue, app.post_queue, app.conf, app.conf_lock)
app.dropbox_th = Dropbox(app.post_queue, app.server_queue, app.conf, app.conf_lock)
app.capture_th.setDevice("video0")
# Launch threads
app.dropbox_th.start()
app.processing_th.start()
app.capture_th.start()
logging.info("Threads started.")
# Restore SIGNINT handler
signal.signal(signal.SIGINT, original_sigint_handler)
# Launch server
rocket_server = Rocket(('localhost', PORT), 'wsgi', {'wsgi_app': app})
app.server_th = Thread(target=rocket_server.start, name='rocket_server')
app.server_th.start()
logging.getLogger("Rocket").setLevel(logging.INFO)
logging.info("Server started.")
try:
while app.server_th.is_alive():
app.server_th.join(1)
except (KeyboardInterrupt, SystemExit):
rocket_server.stop()
logging.info("Server stopped.")
app.capture_th.stop()
app.capture_th.join()
app.processing_th.stop()
if not is_visited:
http_content = "moduuid {} not available".format(mod_uuid)
else:
path_info = environ["PATH_INFO"]
if path_info in MAP_FILES:
path_info = MAP_FILES[path_info]
if path_info in FILES:
content_type = FILES[path_info]
path_info = os.path.join(os.getcwd(), path_info.strip("/"))
f = open(path_info, "r")
http_content = substitue_content(f.read())
if "$$$MODULE_CONTENT$$$" in http_content: http_content = insert_modules(http_content)
except:
traceback.print_exc()
headers = [('Content-type', content_type)]
start_response(status, headers)
return http_content
my_demo = { "wsgi_app": my_simple_app }
if __name__ == '__main__':
log = logging.getLogger('Rocket.Requests')
log.setLevel(logging.INFO)
fmt = logging.Formatter('%(levelname)s:%(name)s:%(message)s')
h = logging.StreamHandler()
h.setFormatter(fmt)
log.addHandler(h)
r = Rocket(interfaces=[('127.0.0.1', 8000), ('::1', 8000)], method='wsgi', app_info=my_demo)
r.start()
