def __init__(self,
width=640,
height=480,
title='Serge',
backcolour=(0, 0, 0),
icon=None,
fullscreen=False):
"""Initialise the engine
:param width: width of the screen
:param height: height of the screen
"""
self.title = title
self.fullscreen = fullscreen
self.addLogger()
self.initEvents()
self.log.info('Starting serge engine (v%s)' % common.version)
SetCurrentEngine(self)
super(Engine, self).__init__()
self.clearWorlds()
self.renderer = render.Renderer(width, height, title, backcolour, icon,
fullscreen)
self.sprites = visual.Register
self._stop_requested = False
self._current_world_name = ''
self._builder = None
self._keyboard = input.Keyboard()
self._mouse = input.Mouse(self)
self._stats = EngineStats()
self._recent_worlds = []
self._profiler = profiler.NullProfiler()
def set_size(self, cw, ch):
self._cw = cw
self._ch = ch
self.reset()
if self.do_render:
del self.r
self.r = render.Renderer(self._cw * self._cc, self._ch * self._cc,
self._cc)
def __init__(self, m):
self.model = m
self.units = [unit.Unit(self.model, x, y) for x, y in self.model.conf.units]
self.all_effects = pygame.sprite.Group()
self.individual_effects = defaultdict(pygame.sprite.Group)
self.all_walkers = pygame.sprite.Group()
self.renderer = render.Renderer()
self.renderer.draw(self.model)
self.clock = pygame.time.Clock()
# Win conditions
self.win_duration_sec = self.model.conf.game["duration"]
self.win_duration_frames = self.model.conf.game["duration"] * FRAMES_PER_SECOND
self.win_living_min_threshold = self.model.conf.game["living_min_threshold"]
self.font = bont.Tiny()
self.news_font = data.load_font(*NEWS_FONT)
self.over_font = data.load_font(*OVER_FONT)
self.selection = None
self.last_selection = None
self.need_destination = False
self.pending_cmd = None
self.buttons = buttons.ButtonRegistry()
self.buttons.add_sprite_button("Cleanse", self.send_reap, 150, 160)
self.buttons.add_sprite_button("Burn", self.send_burn, 150, 180)
self.buttons.add_sprite_button("Block", self.send_block, 205, 160)
self.buttons.add_sprite_button("Cancel", self.cancel_selection, 205, 180)
self.advisor_face = data.load_image("faces/6p.png")
self.frame = 0
self.newsflash = None
# don't fire a newsflash right away
self.next_newsflash = 5 * FRAMES_PER_SECOND
self.hover_info = hover_info.HoverInfo()
self.over = None
self.paused = False
self.final_click = False
self.voice_chan = None
self.select_voice_iter = itertools.cycle(self.select_voices)
music.enqueue("minor1")
def main():
pygame.init()
pygame.font.init()
background = pygame.display.set_mode((constants.X_RES, constants.Y_RES))
pygame.display.set_caption("Circulatory Diagram")
clock = pygame.time.Clock()
person = circulatory.Organism()
renderer = render.Renderer(background, person)
should_exit = False
frame_time = 7 # TODO: this is a hack used for initial flow cycle
frame = 0
while not should_exit:
for event in pygame.event.get():
if event.type == pygame.QUIT:
should_exit = True
if event.type == pygame.MOUSEBUTTONDOWN:
for renderable in [
x for x in renderer.renderables
if x.rect.collidepoint(pygame.mouse.get_pos())
]:
if renderable.type == "button":
if renderable.data == "reset":
renderer.notify("Resetting Model",
constants.NOTIFICATION_DURATION)
person.reset()
elif renderable.data == "heal":
renderer.notify("Healing",
constants.NOTIFICATION_DURATION)
person.heal()
elif renderable.type == "bloodsource":
print(renderable.data)
if not renderable.data.broken:
person.bleeding = True
person.circulatory_system.destroy_vessel(
renderable.data)
person.tick(frame_time)
renderer.draw_frame(frame)
pygame.display.update()
clock.tick(constants.FRAMERATE)
frame_time = clock.get_time()
frame += 1
def run_replay_monitor(renderer_process_connection, combined_level_bounds):
class IpcReplayClient:
def __init__(self, connection):
self._connection = connection
# replay data
self.tile_data = None
self.current_replays = None
# end of game data
self.end_of_game_stats = None
self.training_level_medal = None
self.diamond_medal = None
def try_get_next_replay(self):
renderer_process_connection.send((REQUEST_REPLAY,))
event = renderer_process_connection.recv()
if event[0] is NEW_REPLAY:
self.tile_data = event[1]
self.current_replays = event[2]
return True
elif event[0] is END_OF_GAME_EVENT:
self.end_of_game_stats = event[1]
self.training_level_medal = event[2]
self.diamond_medal = event[3]
return False
return False
ipc_replay_client = IpcReplayClient(renderer_process_connection)
renderer = render.Renderer(combined_level_bounds)
while ipc_replay_client.try_get_next_replay():
action_sources = [ReplayActionSource(replay) for replay in ipc_replay_client.current_replays]
renderer.render_main(ipc_replay_client.tile_data, action_sources)
end_of_game_renderer.render_end_of_game_stats(
ipc_replay_client.end_of_game_stats.games_attempted,
ipc_replay_client.end_of_game_stats.games_won,
ipc_replay_client.end_of_game_stats.training_level_count,
ipc_replay_client.training_level_medal,
ipc_replay_client.end_of_game_stats.diamond_count,
ipc_replay_client.diamond_medal
)
def __init__(self,
width=640,
height=480,
title='Serge',
backcolour=(0, 0, 0),
icon=None):
"""Initialise the engine"""
self.addLogger()
self.log.info('Starting serge engine (v%s)' % common.version)
SetCurrentEngine(self)
super(Engine, self).__init__()
self.clearWorlds()
self.renderer = render.Renderer(width, height, title, backcolour, icon)
self.sprites = visual.Register
self._stop_requested = False
self._current_world_name = ''
self._builder = None
self._keyboard = input.Keyboard()
self._mouse = input.Mouse(self)
self._stats = EngineStats()
def start(self):
r = render.Renderer(self._cw * self._cc, self._ch * self._cc, self._cc)
while self.running:
# process all events
self.process_events()
# move snake
self.move_snake()
self.update_score()
if not self.suppressed:
r.render(self.get_items(), self.score)
if self.discrete:
while not self.moved and self.running:
self.process_events()
self.moved = False
else:
self.fps_clock.tick(FPS)
if self.score > self.high_score:
self.high_score = self.score
if not self.suppressed:
print 'Game over. Score: {0}. High score: {1}.'.format(
self.score, self.high_score)
def __init__(self, tk_master, opengl_context):
tkinter.Frame.__init__(self, tk_master)
self.tk_master = tk_master
self.renderer = render.Renderer(opengl_context)
self.tools = [
(Camera_Pan_Tool(), 'Pan'),
(Axis_Aligned_Scaling_Tool(), 'AA-Scale'),
(Axis_Aligned_Rotation_Tool(), 'AA-Rot'),
(Mask_Editing_Tool(), 'Masking'),
]
self.setup_interface()
self.current_scene_fname = None
self.selected_m2_tool = self.tools[0][0]
self.selected_m1_tool = self.tools[1][0]
self.selected_axis = 0
self.selected_objects = []
self.show_vanishing_points = True
def __init__(self, do_render=True):
self._cc = 20
self._cw = 32
self._ch = 24
self.do_render = do_render
if self.do_render: # BIG RED NOTICE HERE
global pygame # -----------------------
global render # Only import into global
import pygame # namespace if the
import render # render flag is set!
pygame.init()
self.score = 0
self.trap = (0, 0)
self.mouse = (0, 0)
self.cheese = (0, 0)
self.force_kill = False
self.cat = False
self.move_chance = 0.07
self.easy = False
self.reset()
if self.do_render:
self.r = render.Renderer(self._cw * self._cc, self._ch * self._cc,
self._cc)
def __init__(self):
self.title = data.load_image("title.png")
self.next_mode = self
self.model = sim.Map("level1")
self.renderer = render.Renderer()
self.renderer.draw(self.model)
def play_level(n):
def build_level():
self.new_mode = game.Game(sim.Map("level" + str(n)))
return build_level
self.buttons = buttons.ButtonRegistry()
self.buttons.add_sprite_button("Level 1", play_level(1), 96, 160)
self.buttons.add_sprite_button("Level 2", play_level(2), 150, 160)
self.buttons.add_sprite_button("Level 3", play_level(3), 205, 160)
self.buttons.add_sprite_button("Tutorial", self.new_tutorial, 150, 180)
self.buttons.add_sprite_button("Quit", self.quit_game, 205, 180)
self.new_mode = self
music.enqueue("major")
def enter(self):
self.r = render.Renderer(gRootConsole, gWidth, gHeight)
self.help_statusbar = menu.HelpStatusBar(gRootConsole, gWidth, gHeight)
#clears the status bar after 10 seconds
self.help_statusbar_timer = None
self.inventory = menu.Inventory(gRootConsole, gWidth, gHeight)
self.lm = level.LevelManager()
self.lm.inventory = self.inventory
if self.fsm.game_continue:
print("LOADING")
self.lm.load_save("save.json")
self.player = self.lm.player
else:
print("NEW LEVEL")
self.lm.new_level()
# self.lm.load_level("basic_starter_level.json")
self.player = self.lm.player
self.lm.level.objects.append(self.player)
self.interaction_state = GameState.Game.ControlState.ROAM
self.controls = control.MainControls(self.player, self.r, self.lm.level)
self.interaction_controls = control.InteractionControls(self.player, self.lm.level)
self.controls.emitter.bind(interaction=self.on_interaction)
self.controls.emitter.bind(inventory_open=self.on_inventory_open)
self.controls.emitter.bind(in_game_menu=self.on_in_game_menu_open)
self.controls.emitter.bind(pickup_item=self.on_item_pickup)
self.controls.emitter.bind(simple_crafting_menu=self.on_simple_crafting_menu)
self.interaction_controls.emitter.bind(interaction_direction=self.on_interaction_direction)
self.conversation_controls = control.ConversationControls()
#we need a handle for the text window to be persitent or else the function will not be called so we need this textwindow variable
self.text_window = None
#inventory
self.inventory_controls = control.InventoryControls()
self.inventory_controls.emitter.bind(move_down=self.inventory.move_down)
self.inventory_controls.emitter.bind(move_up=self.inventory.move_up)
self.inventory_controls.emitter.bind(select=self.inventory.select)
self.inventory_controls.emitter.bind(cancel=self.on_inventory_close)
self.inventory_controls.emitter.bind(drop=self.inventory.drop_item)
#tools
self.tool_controls = control.ToolControls(self.player, self.lm.level)
self.tool_controls.emitter.bind(direction=self.on_tool_use_direction)
#non-tools
self.nontool_controls = control.NonToolsControls(self.player, self.lm.level)
self.nontool_controls.emitter.bind(direction=self.on_nontool_use_direction)
self.nontool_handler = item.NonToolHandler(self.player, self.lm.level)
#in game menu
self.menu_controls = control.MenuControls()
self.in_game_menu = None # needs to be none just like for the text window
#crafting menu
self.simple_crafting_controls = control.SimpleCraftingControls()
self.simple_crafting_menu = None
self.simple_crafting_submenu_controls = control.SimpleCraftingSubmenuControls()
self.simple_crafting_submenu = None
#global events
self.tool_handler = item.ToolHandler(self.player, self.lm.level)
# gEventHandler.bind("inventory_item_close", self.on_inventory_close)
self._last_used = None
gEventHandler.bind("use_tool", self.on_use_tool)
gEventHandler.bind("drop_item", self.on_drop_item)
gEventHandler.bind("use_non_tool", self.on_nontool_use)
gEventHandler.bind("interact_description", self.interact_description)
gEventHandler.bind("interact_npc", self.interact_npc)
gEventHandler.bind("interact_door", self.interact_door)
# Crafting submenu
gEventHandler.bind("simple_crafting_submenu_open", self.on_simple_crafting_submenu_open)
gEventHandler.bind("simple_crafting_craft", self.on_simple_crafting_craft)
def __init__(self, parent=None):
super().__init__(parent)
self.renderer = render.Renderer()
if __name__ == '__main__':
window = pyglet.window.Window(width=1600, height=800)
simulation = Simulation()
#for i in range(20):
# for j in range(30):
# simulation.add_device_to_world(devices.ConnectorDevice((i*50,j*50)))
theme = {
'background_color': c_blue,
'gui_frame_color': c_orange,
'node_selection': c_red,
'wire_color': c_orange
}
gui = GUI(window, simulation, theme)
renderer = render.Renderer(window, theme)
@window.event
def on_mouse_motion(x, y, dx, dy):
gui.update_mouse_position(x, y)
#@window.event
#def on_key_release(symbol, modifiers):
# if symbol == 32:
# simulation.current_mode += 1
# simulation.current_mode %= len(MODES)
# print('mode: ', MODES[simulation.current_mode])
@window.event
def on_mouse_release(x, y, button, modifiers):
if not gui.on_mouse_release_event(x, y, button, modifiers):
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
import render
from actionsource import KeyboardActionSource
from level_loader import load_level_filepath
import os.path
if __name__ == '__main__':
level_data = load_level_filepath(os.path.join('Data', 'Test', 'goal_advanced.json'))
action_source = KeyboardActionSource()
renderer = render.Renderer((len(level_data[0]), len(level_data)))
renderer.render_main(level_data, [action_source])
import pygame import render import config renderer = render.Renderer(config.SCREEN_SIZE, config.ROOM_SIZE) import mouse import keyboard import event import loop import scene pygame.init() mouse = mouse.Mouse() keyboard = keyboard.Keyboard() handler = event.Handler(mouse, keyboard) scene = scene.Scene(mouse, keyboard) loop = loop.Loop(renderer, handler, scene) while not loop.update(): pass pygame.quit()
import lib
import model
import render
if __name__ == '__main__':
mebel = model.Calosc()
renderer = render.Renderer()
print(model.podsumuj())
if renderer.init_graphics():
renderer.render(mebel)
else:
print("Renderer init error")
def renderer(i, name):
ren = render.Renderer(i, name)
ren.render_loop()
print "render process ending."
return True
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
import render
from actionsource import ReplayActionSource
from gamelogic import ActionTypes
import argparse
import json
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Visualise a replay.')
parser.add_argument('replay_file_name',
type=str,
help='the name of the replay file to load')
parser.add_argument('--replay_index',
type=int,
default=0,
help='which replay in the file to run')
args = parser.parse_args()
with open(args.replay_file_name) as f:
data = json.load(f)
tile_data = data["tile_data"]
replays = data["replays"]
action_source = ReplayActionSource(replays[args.replay_index])
renderer = render.Renderer((len(tile_data[0]), len(tile_data)))
renderer.render_main(tile_data, [action_source])
#draw the player
renderer.render_object(
renderer.surfaces.left_paddle,
(self.left_paddle.x, self.left_paddle.y))
#draw the ai
renderer.render_object(
renderer.surfaces.right_paddle,
(self.right_paddle.x, self.right_paddle.y))
#draw the ball
renderer.render_object(renderer.surfaces.ball,
(self.ball.x, self.ball.y))
elif self.game_state == constants.GAMESTATE_MENU:
renderer.render_object(renderer.surfaces.main_menu, (0, 0))
elif self.game_state == constants.GAMESTATE_OPTIONS:
renderer.render_object(renderer.surfaces.options_menu, (0, 0))
elif self.game_state == constants.GAMESTATE_EXIT_PROMPT:
pass
pygame.display.update()
self.clock.tick(self.tick)
if __name__ == "__main__":
game = Game()
renderer = render.Renderer(game.gameDisplay)
game.main_loop()
pygame.quit()
quit()
