def switch_to(self, name):
log.process('state switched to: %s', name)
assert self.state_stack[-1] != name
self._current().on_leave(name)
last_name = self.state_stack[-1]
self.state_stack[-1] = name
self._current().on_enter(last_name)
def push(self, name):
log.process('state pushed: %s', self.state_stack[-1])
assert name != self.state_stack[-1]
self._current().on_pushed(name)
last_name = self.state_stack[-1]
self.state_stack.append(name)
self._current().on_enter(last_name)
def pop(self):
assert self.state_stack
log.process('state popped: %s', self.state_stack[-1])
self._current().on_leave(self.state_stack[-2])
last_name = self.state_stack[-1]
self.state_stack.pop()
self._current().on_popped(last_name)
def switch_to_scene(self, scene_name):
"""
进入到场景。
:param scene_name: 场景名称，必须全局唯一
:return:
"""
scene_config = G.res_mgr.get_scene_config(scene_name)
# 保存当前scene的数据
if self.scene and self.hero:
pos = self.hero.get_pos()
self.scene.set('hero_pos', (pos[0], pos[1]))
# 切换scene
if not scene_name:
scene_name = self.slot.get_current_scene()
assert scene_name
self.scene = self.slot.switch_to_scene(scene_name)
if not self.scene:
log.error('%s', self.slot.get_current_scene())
assert self.scene
self.slot.save()
is_new_scene = not self.scene.load()
# 地图生成器
self.map_generator = G.config_mgr.get_map_config(scene_config['map_generator'])()
# 载入英雄数据
if self.hero:
if is_new_scene:
log.process('set hero to new position')
r, c = self.map_generator.get_start_tile()
self.hero.set_pos(c * self.chunk_tile_size, r * self.chunk_tile_size)
else:
log.process('set hero to old position')
x, y = self.scene.get('hero_pos')
self.hero.set_pos(x, y, 0)
else:
if is_new_scene:
log.process("creating new hero")
pos = self.map_generator.get_start_tile()
self.hero = G.spawner.spawn_default('hero', pos[1] * self.chunk_tile_size,
pos[1] * self.chunk_tile_size)
else:
log.process('creating hero from storage data')
hero_data = self.slot.get('hero')
self.hero = G.spawner.spawn_from_storage(hero_data)
assert self.hero
G.operation.set_target(self.hero)
# 换装
self.equipment_models = HeroEquipmentModels(self.hero)
# shader
model = self.hero.get_component(ObjAnimator).get_actor_np()
model.set_shader(G.res_mgr.get_shader('hero'))
def on_enter(self, last_name):
log.process("creating inventory & menu")
G.gui_mgr.create_inventory()
G.gui_mgr.create_game_menu()
G.gui_mgr.set_game_menu_visible(self._main_menu_visible)
G.gui_mgr.set_event_handler('game_menu.continue', self._handler_continue)
G.gui_mgr.set_event_handler('game_menu.save', self._handler_save)
G.gui_mgr.set_event_handler('game_menu.exit', self._handler_exit)
log.process("creating game manager")
G.game_mgr = game_manager.GameManager()
log.process('creating camera manager')
G.camera_mgr = camera.CameraManager()
log.process('starting operation')
G.operation.set_enabled(True)
G.accept("escape", self._handler_escape)
def __init__(self):
G.post_effects = post_effects.PostEffects()
def f():
G.post_effects.turn_on()
G.accept('z', f)
if False:
model = G.loader.loadModel("assets/blender/box.egg")
model.reparent_to(G.render)
G.run()
return
log.process('setting font')
log.process('creating managers')
G.storage_mgr = storage_manager.StorageManager()
G.storage_mgr.load()
G.res_mgr = resource_manager.ResourceManager()
G.spawner = spawner.Spawner()
G.config_mgr = config_manager.ConfigManager()
G.config_mgr.register_map_config('perlin', PerlinMapGenerator)
G.config_mgr.register_tile_config('default', 'assets/images/tiles/tiles.json')
G.state_mgr = states.StatesManager("menu.menu")
G.state_mgr.add_state(game_states.MainMenuState())
G.state_mgr.add_state(game_states.GamePlayState())
G.state_mgr.add_state(game_states.GamePauseState())
G.gui_mgr = gui_system.GUIManager()
G.operation = operation.Operation(None)
G.context = context.Context()
log.process("entering main loop")
G.accept('f1', self._render_analysis)
G.taskMgr.add(self.physical_loop, name="physical loop")
G.taskMgr.add(self.main_loop_task, name="main loop")
self._target_framerate = 30.
#self.main_loop()
G.run()
self.main_loop()
log.process("main loop finished")
import numpy as np
import os, sys, time
import torch
import importlib
import options
from util import log
log.process(os.getpid())
log.title("[{}] (evaluate SDF-SRN)".format(sys.argv[0]))
opt_cmd = options.parse_arguments(sys.argv[1:])
opt = options.set(opt_cmd=opt_cmd)
with torch.cuda.device(opt.device):
model = importlib.import_module("model.{}".format(opt.model))
m = model.Model(opt)
m.load_dataset(opt,eval_split="test" if opt.data.dataset=="shapenet" else \
"val" if opt.data.dataset=="pascal3d" else None)
m.build_networks(opt)
m.restore_checkpoint(opt)
m.setup_visualizer(opt)
m.evaluate(opt)
def __init__(self):
self.filters = None
self.scene = None
self.map_generator = None
self.hero = None
self.equipment_models = None
# 雾效
f = .7
self.fog = fog.LinearFog(f, f, f, 70, 140)
#self.fog.switch()
# 背包系统
self.inventory = InventoryManager()
self.give_hero_item_by_name("sapling", 3)
def add_apples():
self.give_hero_item_by_name('axe', 1)
self.give_hero_item_by_name('sword', 1)
self.give_hero_item_by_name('box', 1)
debug.add_debug_key('c', add_apples)
# 制造系统
log.process('creating craft manager')
self.craft_mgr = craft_manager.CraftManager()
self.craft_mgr.register_recipes(json.loads(open('assets/json/recipes.json').read()))
# 载入存档
log.process('loading slot storage')
self.slot = G.storage_mgr.get_or_create_slot_entry(G.context.slot_name)
G.storage_mgr.save_slots_entry()
if self.slot.load():
log.process('slot storage loaded')
self.switch_to_scene(None)
else:
log.process('slot storage not found, entering default scene')
self.switch_to_scene('default')
# 载入inventory
self.inventory.on_load(self.slot)
# 设置chunk manager的存档
log.process('creating chunk manager')
assert G.loader
self.chunk_mgr = chunk_manager.ChunkManager(
texture_config=G.config_mgr.get_tile_config('default'),
spawner=G.spawner,
map_generator= self.map_generator,
storage_mgr=self.scene,
chunk_title_count=10, chunk_tile_size=self.chunk_tile_size, chunk_count=36)
log.process('creating ground collider')
self._ground = ground.create() # TODO remove it
log.process('creating lights')
lights.create() # TODO remove it
log.process('game manager initialized!')
def on_enter(self, last_name):
log.process("creating main menu")
G.gui_mgr.create_main_menu()
G.gui_mgr.set_event_handler('main_menu.new', self._start_new_game)