def setup(self):
"""
Setup test case
"""
self.config = Configuration(Model(), herculeum.config.levels, mock(),
mock())
self.config.initialise()
def load_configuration(self, controls, surface_manager):
"""
Load configuration
"""
self.world = Model()
self.config = Configuration(self.world, herculeum.config.levels,
controls, surface_manager)
self.config.initialise()
def setup(self):
"""
Setup test case
"""
base_path = detect_base_path()
self.config = Configuration(base_path, mock())
self.config.initialise(herculeum.config.levels)
def load_configuration(self):
"""
Load configuration
"""
self.world = Model()
self.config = Configuration(self.base_path, self.world)
self.config.initialise(herculeum.config.levels)
def load_configuration(self, controls, surface_manager):
"""
Load configuration
"""
self.world = Model()
self.config = Configuration(self.world, herculeum.config.levels, controls, surface_manager)
self.config.initialise()
def setup(self):
"""
Setup test case
"""
self.config = Configuration(Model(),
herculeum.config.levels,
mock(),
mock())
self.config.initialise()
class Application():
"""
This class represents main application
"""
def __init__(self):
super().__init__()
self.config = None
self.gui = None
self.world = None
self.running = 1
self.logger = None
self.screen = None
self.log_level = None
def load_configuration(self, controls, surface_manager):
"""
Load configuration
"""
self.world = Model()
self.config = Configuration(self.world,
herculeum.config.levels,
controls,
surface_manager)
self.config.initialise()
def run(self, user_interface):
"""
Starts the application
"""
user_interface.show_main_window()
def enable_cheat(self):
"""
Enables cheat mode
.. versionadded:: 0.9
"""
print('Cheat code activated')
for spec in self.level_generator_factory.portal_adder_configurations:
spec.chance = 100
def __get_surface_manager(self):
"""
Get surface manager
"""
return self.config.surface_manager
def start_logging(self):
"""
Start logging for the system
"""
if self.log_level != 'none':
logging.basicConfig(filename='pyherc.log',
level=self.log_level)
self.logger = logging.getLogger('pyherc.main.Application')
self.logger.info("Logging started")
def __get_action_factory(self):
"""
Get action factory instance
Returns:
ActionFactory
"""
return self.config.action_factory
def __get_creature_generator(self):
"""
Get creature generator
Returns:
CreatureGenerator
"""
return self.config.creature_generator
def __get_item_generator(self):
"""
Get item generator
Returns:
ItemGenerator
"""
return self.config.item_generator
def __get_level_generator_factory(self):
"""
Get level generator factory
"""
return self.config.level_generator_factory
def __get_rng(self):
"""
Get random number generator
"""
return self.config.rng
def __get_rules_engine(self):
"""
Get rules engine
"""
return self.config.rules_engine
def __get_player_generator(self):
"""
Get player generator
"""
return self.config.player_generator
def __get_trap_generator(self):
"""
Get trap generator
"""
return self.config.trap_generator
surface_manager = property(__get_surface_manager)
action_factory = property(__get_action_factory)
creature_generator = property(__get_creature_generator)
player_generator = property(__get_player_generator)
trap_generator = property(__get_trap_generator)
item_generator = property(__get_item_generator)
level_generator_factory = property(__get_level_generator_factory)
rng = property(__get_rng)
rules_engine = property(__get_rules_engine)
class TestMainConfiguration():
"""
Tests for main configuration
"""
def __init__(self):
"""
Default constructor
"""
self.config = None
def setup(self):
"""
Setup test case
"""
base_path = detect_base_path()
self.config = Configuration(base_path, mock())
self.config.initialise(herculeum.config.levels)
def test_initialisation(self):
"""
Test that main configuration can be read and initialised properly
Note:
This test reads configuration from resources directory
"""
config = self.config
assert_that(config.resolution, is_(not_none()))
assert_that(config.resolution, is_(not_none()))
assert_that(config.full_screen, is_(not_none()))
assert_that(config.caption, is_(not_none()))
assert_that(config.surface_manager, is_(not_none()))
assert_that(config.action_factory, is_(not_none()))
assert_that(config.base_path, is_(not_none()))
assert_that(config.item_generator, is_(not_none()))
assert_that(config.creature_generator, is_(not_none()))
assert_that(config.level_generator_factory, is_(not_none()))
assert_that(config.level_size, is_(not_none()))
assert_that(config.base_path, is_(not_none()))
assert_that(config.model, is_(not_none()))
assert_that(config.rng, is_(not_none()))
def test_upper_catacombs_generator(self):
"""
Test that upper catacombs level generator can be retrieved
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper catacombs')
def test_upper_crypt_generator(self):
"""
Test that upper crypt level generator can be retrieved
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper crypt')
def test_inventory_factory_has_been_initialised(self):
"""
Test that inventory action factory has been initialised
"""
factory = self.config.action_factory.get_sub_factory(
InventoryParameters(character = None,
item = None,
sub_action = 'pick up'))
assert_that(factory, is_(not_none()))
class TestMainConfiguration():
"""
Tests for main configuration
"""
def __init__(self):
"""
Default constructor
"""
self.config = None
def setup(self):
"""
Setup test case
"""
self.config = Configuration(Model(), herculeum.config.levels, mock(),
mock())
self.config.initialise()
def test_initialisation(self):
"""
Test that main configuration can be read and initialised properly
Note:
This test reads configuration from resources directory
"""
config = self.config
assert_that(config.surface_manager, is_(not_none()))
assert_that(config.action_factory, is_(not_none()))
assert_that(config.item_generator, is_(not_none()))
assert_that(config.creature_generator, is_(not_none()))
assert_that(config.level_generator_factory, is_(not_none()))
assert_that(config.level_size, is_(not_none()))
assert_that(config.model, is_(not_none()))
assert_that(config.rng, is_(not_none()))
def test_first_gate_generator(self):
"""
Test that first gate level generator can be retrieved and used
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('first gate')
level = generator(None)
def test_upper_mines_generator(self):
"""
Test that upper mines level generator can be retrieved
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper mines')
level = generator(None)
def test_lower_mines_generator(self):
"""
Test that lower mines level can be created
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('lower mines')
level = generator(None)
def test_forge_generator(self):
"""
Test that forge can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('forge')
level = generator(None)
def test_lower_caverns_generator(self):
"""
Test that lower caverns can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('lower caverns')
level = generator(None)
def test_middle_caverns_generator(self):
"""
Test that middle caverns can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('middle caverns')
level = generator(None)
def test_upper_caverns_generator(self):
"""
Test that upper caverns can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper caverns')
level = generator(None)
def test_second_gate_generator(self):
"""
Test that second gate can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('second gate')
level = generator(None)
def test_lower_maze_generator(self):
"""
Test that lower maze can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('lower maze')
level = generator(None)
def test_courtyard_generator(self):
"""
Test that courtyard can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('courtyard')
level = generator(None)
def test_upper_maze_generator(self):
"""
Test that upper maze can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper maze')
level = generator(None)
def test_third_gate_generator(self):
"""
Test that third gate can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('third gate')
level = generator(None)
def test_lower_catacombs_generator(self):
"""
Test that lower catacombs can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('lower catacombs')
level = generator(None)
def test_central_catacombs_generator(self):
"""
Test that central catacombs can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('central catacombs')
level = generator(None)
def test_upper_catacombs_generator(self):
"""
Test that upper catacombs can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper catacombs')
level = generator(None)
def test_final_gate_generator(self):
"""
Test that final gate can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('final gate')
level = generator(None)
def test_inventory_factory_has_been_initialised(self):
"""
Test that inventory action factory has been initialised
"""
factory = self.config.action_factory.get_sub_factory(
InventoryParameters(character=None,
item=None,
sub_action='pick up'))
assert_that(factory, is_(not_none()))
def test_player_character_generator_has_been_initialised(self):
"""
Test that player character generator is initialised during
configuration phase
"""
assert_that(self.config.player_generator, is_(not_none()))
class TestMainConfiguration():
"""
Tests for main configuration
"""
def __init__(self):
"""
Default constructor
"""
self.config = None
def setup(self):
"""
Setup test case
"""
self.config = Configuration(Model(),
herculeum.config.levels,
mock(),
mock())
self.config.initialise()
def test_initialisation(self):
"""
Test that main configuration can be read and initialised properly
Note:
This test reads configuration from resources directory
"""
config = self.config
assert_that(config.surface_manager, is_(not_none()))
assert_that(config.action_factory, is_(not_none()))
assert_that(config.item_generator, is_(not_none()))
assert_that(config.creature_generator, is_(not_none()))
assert_that(config.level_generator_factory, is_(not_none()))
assert_that(config.level_size, is_(not_none()))
assert_that(config.model, is_(not_none()))
assert_that(config.rng, is_(not_none()))
def test_first_gate_generator(self):
"""
Test that first gate level generator can be retrieved and used
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('first gate')
level = generator(None)
def test_upper_mines_generator(self):
"""
Test that upper mines level generator can be retrieved
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper mines')
level = generator(None)
def test_lower_mines_generator(self):
"""
Test that lower mines level can be created
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('lower mines')
level = generator(None)
def test_forge_generator(self):
"""
Test that forge can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('forge')
level = generator(None)
def test_lower_caverns_generator(self):
"""
Test that lower caverns can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('lower caverns')
level = generator(None)
def test_middle_caverns_generator(self):
"""
Test that middle caverns can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('middle caverns')
level = generator(None)
def test_upper_caverns_generator(self):
"""
Test that upper caverns can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper caverns')
level = generator(None)
def test_second_gate_generator(self):
"""
Test that second gate can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('second gate')
level = generator(None)
def test_lower_maze_generator(self):
"""
Test that lower maze can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('lower maze')
level = generator(None)
def test_courtyard_generator(self):
"""
Test that courtyard can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('courtyard')
level = generator(None)
def test_upper_maze_generator(self):
"""
Test that upper maze can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper maze')
level = generator(None)
def test_third_gate_generator(self):
"""
Test that third gate can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('third gate')
level = generator(None)
def test_lower_catacombs_generator(self):
"""
Test that lower catacombs can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('lower catacombs')
level = generator(None)
def test_central_catacombs_generator(self):
"""
Test that central catacombs can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('central catacombs')
level = generator(None)
def test_upper_catacombs_generator(self):
"""
Test that upper catacombs can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('upper catacombs')
level = generator(None)
def test_final_gate_generator(self):
"""
Test that final gate can be generated
"""
factory = self.config.level_generator_factory
generator = factory.get_generator('final gate')
level = generator(None)
def test_inventory_factory_has_been_initialised(self):
"""
Test that inventory action factory has been initialised
"""
factory = self.config.action_factory.get_sub_factory(
InventoryParameters(character = None,
item = None,
sub_action = 'pick up'))
assert_that(factory, is_(not_none()))
def test_player_character_generator_has_been_initialised(self):
"""
Test that player character generator is initialised during
configuration phase
"""
assert_that(self.config.player_generator, is_(not_none()))
class Application(object):
"""
This class represents main application
"""
def __init__(self):
super(Application, self).__init__()
self.config = None
self.gui = None
self.world = None
self.running = 1
self.base_path = None
self.logger = None
self.screen = None
self.log_level = None
def process_command_line(self):
"""
Process command line options
"""
log_levels = {'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL}
args = sys.argv
for argument in args:
if argument in log_levels:
self.log_level = log_levels[argument]
def load_configuration(self):
"""
Load configuration
"""
self.world = Model()
self.config = Configuration(self.base_path, self.world)
self.config.initialise(herculeum.config.levels)
def run(self):
"""
Starts the application
"""
self.screen = pygame.display.set_mode((800, 600),
pygame.SWSURFACE)
self.gui = MainWindow(self,
self.base_path,
self.surface_manager)
menu = StartMenu(self,
self.surface_manager)
self.gui.connect(pgu.gui.QUIT, self.gui.quit, None)
self.gui.run(menu, screen = self.screen)
def __get_surface_manager(self):
"""
Get surface manager
"""
return self.config.surface_manager
def start_logging(self):
"""
Start logging for the system
"""
logging.basicConfig(filename='pyherc.log',
level=self.log_level)
self.logger = logging.getLogger('pyherc.main.Application')
self.logger.info("Logging started")
def change_state(self, state):
"""
Change state of the gui
Args:
state: String specifying which state to display
"""
self.gui.change_state(state)
def __get_action_factory(self):
"""
Get action factory instance
Returns:
ActionFactory
"""
return self.config.action_factory
def __get_creature_generator(self):
"""
Get creature generator
Returns:
CreatureGenerator
"""
return self.config.creature_generator
def __get_item_generator(self):
"""
Get item generator
Returns:
ItemGenerator
"""
return self.config.item_generator
def __get_level_generator_factory(self):
"""
Get level generator factory
"""
return self.config.level_generator_factory
def __get_rng(self):
"""
Get random number generator
"""
return self.config.rng
def detect_resource_directory(self):
"""
Detects location of resources directory and updates self.base_path
"""
search_directory = '.'
current = os.path.normpath(os.path.join(os.getcwd(), search_directory))
while not os.path.exists(os.path.join(current, 'resources')):
search_directory = search_directory +'/..'
current = os.path.normpath(os.path.join(os.getcwd(),
search_directory))
self.base_path = os.path.join(current, 'resources')
surface_manager = property(__get_surface_manager)
action_factory = property(__get_action_factory)
creature_generator = property(__get_creature_generator)
item_generator = property(__get_item_generator)
level_generator_factory = property(__get_level_generator_factory)
rng = property(__get_rng)
class Application():
"""
This class represents main application
"""
def __init__(self):
super().__init__()
self.config = None
self.gui = None
self.world = None
self.running = 1
self.logger = None
self.screen = None
self.log_level = None
def load_configuration(self, controls, surface_manager):
"""
Load configuration
"""
self.world = Model()
self.config = Configuration(self.world, herculeum.config.levels,
controls, surface_manager)
self.config.initialise()
def run(self, user_interface):
"""
Starts the application
"""
user_interface.show_main_window()
def enable_cheat(self):
"""
Enables cheat mode
.. versionadded:: 0.9
"""
print('Cheat code activated')
for spec in self.level_generator_factory.portal_adder_configurations:
spec.chance = 100
def __get_surface_manager(self):
"""
Get surface manager
"""
return self.config.surface_manager
def start_logging(self):
"""
Start logging for the system
"""
if self.log_level != 'none':
logging.basicConfig(filename='pyherc.log', level=self.log_level)
self.logger = logging.getLogger('pyherc.main.Application')
self.logger.info("Logging started")
def __get_action_factory(self):
"""
Get action factory instance
Returns:
ActionFactory
"""
return self.config.action_factory
def __get_creature_generator(self):
"""
Get creature generator
Returns:
CreatureGenerator
"""
return self.config.creature_generator
def __get_item_generator(self):
"""
Get item generator
Returns:
ItemGenerator
"""
return self.config.item_generator
def __get_level_generator_factory(self):
"""
Get level generator factory
"""
return self.config.level_generator_factory
def __get_rng(self):
"""
Get random number generator
"""
return self.config.rng
def __get_rules_engine(self):
"""
Get rules engine
"""
return self.config.rules_engine
def __get_player_generator(self):
"""
Get player generator
"""
return self.config.player_generator
def __get_trap_generator(self):
"""
Get trap generator
"""
return self.config.trap_generator
surface_manager = property(__get_surface_manager)
action_factory = property(__get_action_factory)
creature_generator = property(__get_creature_generator)
player_generator = property(__get_player_generator)
trap_generator = property(__get_trap_generator)
item_generator = property(__get_item_generator)
level_generator_factory = property(__get_level_generator_factory)
rng = property(__get_rng)
rules_engine = property(__get_rules_engine)
