def test_tobbaconist_production_chain(s, p):
    """
	Tobacco is generated by tobacco fields and transferred to the tobacconist for tobacco
	products making
	"""
    settlement, island = settle(s)

    assert Build(BUILDINGS.FARM, 30, 30, island, settlement=settlement)(p)
    assert Build(BUILDINGS.TOBACCO_FIELD,
                 26,
                 30,
                 island,
                 settlement=settlement)(p)

    tobacconist = Build(BUILDINGS.TOBACCONIST,
                        30,
                        26,
                        island,
                        settlement=settlement)(p)

    assert tobacconist

    assert tobacconist.get_component(StorageComponent).inventory[
        RES.TOBACCO_LEAVES] == 0
    assert tobacconist.get_component(StorageComponent).inventory[
        RES.TOBACCO_PRODUCTS] == 0
    s.run(seconds=120)  # 30s tobacco field, 15s tobacconist
    assert tobacconist.get_component(StorageComponent).inventory[
        RES.TOBACCO_PRODUCTS]
def test_tool_production_chain(s, p):
	"""
	Check if a iron mine gathers raw iron, a smeltery produces iron ingots, boards are converted
	to charcoal and tools are produced.

	Pretty much for a single test, but these are rather trivial in their assertions anyway.
	"""
	settlement, island = settle(s)

	assert Build(BUILDINGS.MOUNTAIN, 30, 35, island, ownerless=True)(None)
	assert Build(BUILDINGS.IRON_MINE, 30, 35, island, settlement=settlement)(p)

	charcoal = Build(BUILDINGS.CHARCOAL_BURNER, 25, 35, island, settlement=settlement)(p)
	assert charcoal
	charcoal.get_component(StorageComponent).inventory.alter(RES.BOARDS, 10) # give him boards directly

	assert Build(BUILDINGS.SMELTERY, 25, 30, island, settlement=settlement)(p)

	toolmaker = Build(BUILDINGS.TOOLMAKER, 22, 32, island, settlement=settlement)(p)
	assert toolmaker
	toolmaker.get_component(StorageComponent).inventory.alter(RES.BOARDS, 10) # give him boards directly

	assert toolmaker.get_component(StorageComponent).inventory[RES.TOOLS] == 0
	s.run(seconds=120)
	assert toolmaker.get_component(StorageComponent).inventory[RES.TOOLS]
def test_distillery_production_chain(s, p):
    """
	Raw sugar is generated by sugarcane fields and transferred to the distillery
	for liquor production
	"""
    settlement, island = settle(s)

    assert Build(BUILDINGS.FARM, 30, 30, island, settlement=settlement)(p)
    assert Build(BUILDINGS.SUGARCANE_FIELD,
                 26,
                 30,
                 island,
                 settlement=settlement)(p)

    distillery = Build(BUILDINGS.DISTILLERY,
                       30,
                       26,
                       island,
                       settlement=settlement)(p)

    assert distillery

    assert distillery.get_component(StorageComponent).inventory[RES.SUGAR] == 0
    assert distillery.get_component(StorageComponent).inventory[
        RES.LIQUOR] == 0
    s.run(seconds=60)  # 30s sugarcane field, 12s distillery
    assert distillery.get_component(StorageComponent).inventory[RES.LIQUOR]
def test_farm_crop_production(s, p):
    """
	Check whether the fields produce crops and the crops are collected at the farm
	"""

    settlement, island = settle(s)

    farm = _build_farm(30, 30, island, settlement, p, BUILDINGS.HERBARY,
                       BUILDINGS.SUGARCANE_FIELD, BUILDINGS.VINEYARD,
                       BUILDINGS.TOBACCO_FIELD, BUILDINGS.SPICE_FIELD,
                       BUILDINGS.HOP_FIELD, BUILDINGS.COCOA_FIELD,
                       BUILDINGS.CORN_FIELD)

    assert farm

    primary_resources = (RES.HERBS, RES.RAW_SUGAR, RES.VINES,
                         RES.TOBACCO_PLANTS, RES.SPICE_PLANTS, RES.HOP_PLANTS,
                         RES.COCOA_BEANS, RES.GRAIN)
    secondary_resources = (RES.MEDICAL_HERBS, RES.SUGAR, RES.GRAPES,
                           RES.TOBACCO_LEAVES, RES.SPICES, RES.HOPS, RES.COCOA,
                           RES.CORN)

    for p_res, s_res in zip(primary_resources, secondary_resources):
        assert farm.get_component(StorageComponent).inventory[p_res] == 0
        assert farm.get_component(StorageComponent).inventory[s_res] == 0

    s.run(seconds=60)

    for s_res in secondary_resources:
        assert farm.get_component(StorageComponent).inventory[s_res]
Exemple #5
0
def test_settler_save_load():
	"""Save/loading """
	session, player = new_session()
	settlement, island = settle(session)

	# setup:
	# 1) build settler
	# 2) save/load
	# 3) build main square
	# -> settler won't load properly and not use the resources and die

	settler = Build(BUILDINGS.RESIDENTIAL, 25, 22, island, settlement=settlement)(player)
	assert settler

	main_square = Build(BUILDINGS.MAIN_SQUARE, 23, 24, island, settlement=settlement)(player)
	assert main_square
	main_square.get_component(StorageComponent).inventory.alter(RES.FOOD, 100)

	session = saveload(session)

	session.run(seconds=500)

	tile = session.world.get_tile(Point(25, 22))

	# tile will contain ruin in case of failure
	assert tile.object.id == BUILDINGS.RESIDENTIAL
Exemple #6
0
def test_load_inactive_production():
	"""
	create a savegame with a inactive production, load it
	"""
	session, player = new_session()
	settlement, island = settle(session)

	lj = Build(BUILDINGS.LUMBERJACK, 30, 30, island, settlement=settlement)(player)
	# Set lumberjack to inactive
	lj.get_component(Producer).set_active(active = False)
	worldid = lj.worldid

	session.run(seconds=1)

	fd, filename = tempfile.mkstemp()
	os.close(fd)

	assert session.save(savegamename=filename)

	session.end(keep_map=True)

	# Load game
	session = load_session(filename)
	loadedlj = WorldObject.get_object_by_id(worldid)

	# Make sure it really is not active
	producer = loadedlj.get_component(Producer)
	assert not producer.is_active()

	# Trigger bug #1359
	ToggleActive(producer).execute(session)

	session.end()
def test_cannonfoundry_production_chain(s, p):
    """
	The mine generates iron ore. The charcoal burner produces charcoal out of wooden boards.
	Later the smeltery produces iron ingots out of iron ore and charcoal. Finally, the cannon
	foundry makes cannons out of charcoal, iron ingots and wooden boards.
	"""
    settlement, island = settle(s)

    assert Build(BUILDINGS.MOUNTAIN, 30, 35, island, ownerless=True)(None)
    assert Build(BUILDINGS.MINE, 30, 35, island, settlement=settlement)(p)

    charcoal = Build(BUILDINGS.CHARCOAL_BURNER,
                     25,
                     35,
                     island,
                     settlement=settlement)(p)
    assert charcoal
    charcoal.get_component(StorageComponent).inventory.alter(
        RES.BOARDS, 10)  # give him boards directly

    assert Build(BUILDINGS.SMELTERY, 25, 30, island, settlement=settlement)(p)

    cannonfoundry = Build(BUILDINGS.CANNON_FOUNDRY,
                          22,
                          32,
                          island,
                          settlement=settlement)(p)
    assert cannonfoundry
    cannonfoundry.get_component(StorageComponent).inventory.alter(
        RES.BOARDS, 10)  # give him boards directly

    assert cannonfoundry.get_component(StorageComponent).inventory[
        RES.CANNON] == 0
    s.run(seconds=150)
    assert cannonfoundry.get_component(StorageComponent).inventory[RES.CANNON]
def test_weaponsmith_production_chain(s, p):
    """
	The mine generates iron ore. The charcoal burner produces charcoal out of wooden boards.
	Later the smeltery produces iron ingots out of iron ore and charcoal. Finally, the weaponsmith
	produces swords out of charcoal and iron ingots.
	"""
    settlement, island = settle(s)

    assert Build(BUILDINGS.MOUNTAIN, 30, 35, island, ownerless=True)(None)
    assert Build(BUILDINGS.MINE, 30, 35, island, settlement=settlement)(p)

    charcoal = Build(BUILDINGS.CHARCOAL_BURNER,
                     25,
                     35,
                     island,
                     settlement=settlement)(p)
    assert charcoal
    charcoal.get_component(StorageComponent).inventory.alter(
        RES.BOARDS, 10)  # give him boards directly

    assert Build(BUILDINGS.SMELTERY, 25, 30, island, settlement=settlement)(p)

    weaponsmith = Build(BUILDINGS.WEAPONSMITH,
                        22,
                        32,
                        island,
                        settlement=settlement)(p)
    assert weaponsmith

    assert weaponsmith.get_component(StorageComponent).inventory[
        RES.SWORD] == 0
    s.run(seconds=120)
    assert weaponsmith.get_component(StorageComponent).inventory[RES.SWORD]
def test_ticket_1232(s, p):
	settlement, island = settle(s)
	assert len(s.world.ships) == 2

	boat_builder = Build(BUILDINGS.BOAT_BUILDER, 35, 20, island, settlement=settlement)(p)
	boat_builder.get_component(StorageComponent).inventory.alter(RES.TEXTILE, 10)
	boat_builder.get_component(StorageComponent).inventory.alter(RES.BOARDS, 8)
	assert isinstance(boat_builder.get_component(Producer), QueueProducer)

	production_finished = [False]
	boat_builder.get_component(Producer).add_production_by_id(PRODUCTIONLINES.HUKER)
	production1 = boat_builder.get_component(Producer)._get_production(PRODUCTIONLINES.HUKER)
	production1.add_production_finished_listener(lambda _: production_finished.__setitem__(0, True))
	assert boat_builder.get_component(Producer).is_active()
	while not production_finished[0]:
		s.run(ticks=1)
	assert not boat_builder.get_component(Producer).is_active()
	assert len(s.world.ships) == 3
	# Make sure enough res are available
	boat_builder.get_component(StorageComponent).inventory.alter(RES.TEXTILE, 10)
	boat_builder.get_component(StorageComponent).inventory.alter(RES.BOARDS, 8)
	boat_builder.get_component(StorageComponent).inventory.alter(RES.TOOLS, 5)

	boat_builder.get_component(Producer).add_production_by_id(PRODUCTIONLINES.HUKER)
	assert boat_builder.get_component(Producer).is_active()
	s.run(seconds=130)
	assert not boat_builder.get_component(Producer).is_active()
	assert len(s.world.ships) == 4
def test_pastryshop_production_chain(s, p):
	"""
	The pastryshop makes candles and sugar out of honeycombs. Sugar is later used in combination with
	grapes and cocoa to produce confectioneries. Honeycombs, cocoa and grapes are generated at a farm.
	"""
	settlement, island = settle(s)

	assert Build(BUILDINGS.FARM, 30, 30, island, settlement=settlement)(p)
	assert Build(BUILDINGS.COCOA_FIELD, 26, 30, island, settlement=settlement)(p)
	assert Build(BUILDINGS.VINEYARD, 30, 34, island, settlement=settlement)(p)
	assert Build(BUILDINGS.ALVEARIES, 34, 30, island, settlement=settlement)(p)

	pastryshop = Build(BUILDINGS.PASTRY_SHOP, 30, 26, island, settlement=settlement)(p)

	assert pastryshop

	assert pastryshop.get_component(StorageComponent).inventory[RES.HONEYCOMBS] == 0
	assert pastryshop.get_component(StorageComponent).inventory[RES.SUGAR] == 0
	assert pastryshop.get_component(StorageComponent).inventory[RES.COCOA] == 0
	assert pastryshop.get_component(StorageComponent).inventory[RES.GRAPES] == 0
	assert pastryshop.get_component(StorageComponent).inventory[RES.CANDLES] == 0
	assert pastryshop.get_component(StorageComponent).inventory[RES.CONFECTIONERY] == 0
	s.run(seconds=120) # 30s alvearies, 30s vineyard, 30s cocoa field, 45s pastry shop
	assert pastryshop.get_component(StorageComponent).inventory[RES.CANDLES]
	assert pastryshop.get_component(StorageComponent).inventory[RES.CONFECTIONERY] >= 2
def test_ticket_979(s, p):
	settlement, island = settle(s)
	storage_collectors = settlement.branch_office.get_local_collectors()

	farm = _build_farm(30, 30, BUILDINGS.POTATO_FIELD_CLASS, island, settlement, p)

	# Let it work for a bit
	s.run(seconds=60)
	assert farm.inventory[RES.FOOD_ID]

	# The settlement inventory is already full of food (from the ship): dispose of it
	assert settlement.inventory[RES.FOOD_ID] > 0
	settlement.inventory.alter(RES.FOOD_ID, -settlement.inventory[RES.FOOD_ID])
	assert settlement.inventory[RES.FOOD_ID] == 0

	# Build a road, connecting farm and branch office
	for y in range(23, 30):
		assert Build(BUILDINGS.TRAIL_CLASS, 30, y, island, settlement=settlement)(p)

	# Step forward in time until a collector picked a job
	got_job = False
	while not got_job:
		s.run()
		if any(c.job for c in storage_collectors):
			got_job = True

	Tear(farm)(p)

	# Let the collector reach the not existing target
	s.run(seconds=10)
def test_ticket_979(s, p):
	settlement, island = settle(s)
	storage_collectors = settlement.warehouse.get_component(CollectingComponent).get_local_collectors()

	farm = _build_farm(30, 30, BUILDINGS.POTATO_FIELD, island, settlement, p)

	# Let it work for a bit
	s.run(seconds=60)
	assert farm.get_component(StorageComponent).inventory[RES.FOOD]

	# Depending on auto unloading (which we aren't interested in here),
	# the settlement inventory may already be full of food: dispose of it
	settlement.get_component(StorageComponent).inventory.alter(RES.FOOD, -settlement.get_component(StorageComponent).inventory[RES.FOOD])
	assert settlement.get_component(StorageComponent).inventory[RES.FOOD] == 0

	# Build a road, connecting farm and warehouse
	for y in range(23, 30):
		assert Build(BUILDINGS.TRAIL, 30, y, island, settlement=settlement)(p)

	# Step forward in time until a collector picked a job
	got_job = False
	while not got_job:
		s.run()
		if any(c.job for c in storage_collectors):
			got_job = True

	Tear(farm)(p)

	# Let the collector reach the not existing target
	s.run(seconds=10)
def test_farm_crop_production(s, p):
	"""
	Check whether the fields produce crops and the crops are collected at the farm
	"""

	settlement, island = settle(s)

	farm = _build_farm(30, 30, island, settlement, p, BUILDINGS.HERBARY, BUILDINGS.SUGARCANE_FIELD,
					   BUILDINGS.VINEYARD, BUILDINGS.TOBACCO_FIELD, BUILDINGS.SPICE_FIELD,
					   BUILDINGS.HOP_FIELD, BUILDINGS.COCOA_FIELD, BUILDINGS.CORN_FIELD)

	assert farm

	primary_resources = (RES.HERBS, RES.RAW_SUGAR, RES.VINES, RES.TOBACCO_PLANTS, RES.SPICE_PLANTS,
						 RES.HOP_PLANTS, RES.COCOA_BEANS, RES.GRAIN)
	secondary_resources = (RES.MEDICAL_HERBS, RES.SUGAR, RES.GRAPES, RES.TOBACCO_LEAVES, RES.SPICES,
						   RES.HOPS, RES.COCOA, RES.CORN)

	for p_res, s_res in zip(primary_resources, secondary_resources):
		assert farm.get_component(StorageComponent).inventory[p_res] == 0
		assert farm.get_component(StorageComponent).inventory[s_res] == 0

	s.run(seconds=60)

	for s_res in secondary_resources:
		assert farm.get_component(StorageComponent).inventory[s_res]
def test_productivity_low(session, player):
	settlement, island = settle(session)

	lj = Build(BUILDINGS.CHARCOAL_BURNER_CLASS, 30, 30, island, settlement=settlement)(player)

	called = [False]

	def add_icon(message):
		isinstance(message, AddStatusIcon)
		if message.icon.__class__ == ProductivityLowStatus:
			called.__setitem__(0, True)

	session.message_bus.subscribe_globally(AddStatusIcon, add_icon)


	# precondition
	assert abs(lj.get_component(Producer).capacity_utilisation) < 0.0001

	# Not yet low
	assert not called[0]

	session.run(seconds=60)

	# Now low
	assert called[0]
def create_lumberjack_production_session():
    """Create a saved game with a producing production and then load it."""
    session, player = new_session()
    settlement, island = settle(session)

    for x in [29, 30, 31, 32]:
        Build(
            BUILDINGS.TREE,
            x,
            29,
            island,
            settlement=settlement,
        )(player)
    building = Build(BUILDINGS.LUMBERJACK,
                     30,
                     30,
                     island,
                     settlement=settlement)(player)
    production = building.get_component(Producer).get_productions()[0]

    # wait for the lumberjack to start producing
    while True:
        if production.get_state() is PRODUCTION.STATES.producing:
            break
        session.run(ticks=1)

    fd1, filename1 = tempfile.mkstemp()
    os.close(fd1)
    assert session.save(savegamename=filename1)
    session.end(keep_map=True)

    # load the game
    session = load_session(filename1)
    return session
def test_barracks_production_chain(s, p):
    """
	The weaponsmith produces swords, which are later used to equip soldiers in the barracks.
	"""
    settlement, island = settle(s)

    weaponsmith = Build(BUILDINGS.WEAPONSMITH,
                        30,
                        30,
                        island,
                        settlement=settlement)(p)
    assert weaponsmith

    barracks = Build(BUILDINGS.BARRACKS, 26, 30, island,
                     settlement=settlement)(p)
    assert barracks

    assert weaponsmith.get_component(StorageComponent).inventory[
        RES.CHARCOAL] == 0
    assert weaponsmith.get_component(StorageComponent).inventory[
        RES.IRON_INGOTS] == 0

    assert barracks.get_component(StorageComponent).inventory[RES.GOLD] == 0
    assert barracks.get_component(StorageComponent).inventory[
        UNITS.SWORDSMAN] == 0

    # weaponsmith production chain tested already so supply resources directly
    weaponsmith.get_component(StorageComponent).inventory.alter(
        RES.CHARCOAL, 10)
    weaponsmith.get_component(StorageComponent).inventory.alter(
        RES.IRON_INGOTS, 10)
    barracks.get_component(StorageComponent).inventory.alter(RES.GOLD, 1000)
    s.run(seconds=200)
    assert barracks.get_component(StorageComponent).inventory[UNITS.SWORDSMAN]
def test_hunter_save_load():
	"""Save/loading hunter in different states"""
	session, player = new_session()
	settlement, island = settle(session)

	# setup hunter, trees (to keep animals close) and animals

	hunter = Build(BUILDINGS.HUNTER_CLASS, 30, 30, island, settlement=settlement)(player)
	hunter_worldid = hunter.worldid
	del hunter # invalid after save/load

	for x in xrange(27, 29):
		for y in xrange(25, 28):
			assert Build(BUILDINGS.TREE_CLASS, x, y, island, settlement=settlement)(player)

	CreateUnit(island.worldid, UNITS.WILD_ANIMAL_CLASS, 27, 27)(issuer=None)
	CreateUnit(island.worldid, UNITS.WILD_ANIMAL_CLASS, 28, 27)(issuer=None)
	CreateUnit(island.worldid, UNITS.WILD_ANIMAL_CLASS, 29, 27)(issuer=None)

	# utility
	def saveload(session):
		fd, filename = tempfile.mkstemp()
		os.close(fd)
		assert session.save(savegamename=filename)
		session.end(keep_map=True)
		session =  load_session(filename)
		Scheduler().before_ticking() # late init finish (not ticking already)
		return session

	def get_hunter_collector(session):
		hunter = WorldObject.get_object_by_id(hunter_worldid)
		return hunter.get_component(CollectingComponent)._CollectingComponent__collectors[0]

	def await_transition(session, collector, old_state, new_state):
		assert collector.state == old_state, "expected old state %s, got %s" % (old_state, collector.state)
		while collector.state == old_state:
			session.run(seconds=1)
		assert collector.state == new_state, "expected new state %s, got %s" % (old_state, collector.state)


	sequence = [
	  Collector.states.idle,
	  Collector.states.waiting_for_animal_to_stop,
	  Collector.states.moving_to_target,
	  Collector.states.working,
	  Collector.states.moving_home,
	  Collector.states.idle
	  ]

	# do full run without saveload
	collector = get_hunter_collector(session)
	for i in xrange(len(sequence)-1):
		await_transition(session, collector, sequence[i], sequence[i+1])

	# do full run with saveload
	for i in xrange(len(sequence)-1):
		collector = get_hunter_collector(session)
		await_transition(session, collector, sequence[i], sequence[i+1])
		session = saveload(session)
Exemple #18
0
def test_ticket_1427():
	"""Boatbuilder production progress should be saved properly"""

	session, player = new_session()
	settlement, island = settle(session)

	boat_builder = Build(BUILDINGS.BOATBUILDER_CLASS, 35, 20, island, settlement=settlement)(player)
	worldid = boat_builder.worldid

	# Make sure no boards are available
	settlement.get_component(StorageComponent).inventory.alter(RES.BOARDS_ID, -1000)

	bb_storage = boat_builder.get_component(StorageComponent)

	# Add production to use resources
	bb_producer =  boat_builder.get_component(Producer)
	bb_producer.add_production_by_id(PRODUCTIONLINES.HUKER)
	production = bb_producer._productions[PRODUCTIONLINES.HUKER]

	assert production.progress == 0.0

	bb_storage.inventory.alter(RES.TEXTILE_ID, 10)
	bb_storage.inventory.alter(RES.BOARDS_ID, 6)

	production_line = production._prod_line

	# Make sure the boatbuilder consumes everything in his inventory
	session.run(seconds=10)

	# Check if correctly consumed wood
	assert production_line.consumed_res[RES.BOARDS_ID] == -2

	# Save all production process for later
	expected_consumed_res = production_line.consumed_res
	expected_produced_res = production_line.produced_res
	expected_production = production_line.production
	expected_progress = production.progress

	# Make sure the producer used the boards
	assert bb_storage.inventory[RES.BOARDS_ID] == 0

	fd, filename = tempfile.mkstemp()
	os.close(fd)
	assert session.save(savegamename=filename)
	session.end(keep_map=True)

	# Load game
	session = load_session(filename)
	loadedbb = WorldObject.get_object_by_id(worldid)

	production_loaded = loadedbb.get_component(Producer)._productions[PRODUCTIONLINES.HUKER]
	production_line_loaded = production_loaded._prod_line

	# Make sure everything is loaded correctly
	assert expected_consumed_res == production_line_loaded.consumed_res
	assert expected_produced_res == production_line_loaded.produced_res
	assert expected_production == production_line_loaded.production
	assert expected_progress == production_loaded.progress
def test_ticket_1427():
	"""Boatbuilder production progress should be saved properly"""

	session, player = new_session()
	settlement, island = settle(session)

	boat_builder = Build(BUILDINGS.BOAT_BUILDER, 35, 20, island, settlement=settlement)(player)
	worldid = boat_builder.worldid

	# Make sure no boards are available
	settlement.get_component(StorageComponent).inventory.alter(RES.BOARDS, -1000)

	bb_storage = boat_builder.get_component(StorageComponent)

	# Add production to use resources
	bb_producer = boat_builder.get_component(Producer)
	bb_producer.add_production_by_id(PRODUCTIONLINES.HUKER)
	production = bb_producer._productions[PRODUCTIONLINES.HUKER]

	assert production.progress == 0.0

	bb_storage.inventory.alter(RES.TEXTILE, 10)
	bb_storage.inventory.alter(RES.BOARDS, 6)

	production_line = production._prod_line

	# Make sure the boatbuilder consumes everything in its inventory
	session.run(seconds=10)

	# Check if correctly consumed wood
	assert production_line.consumed_res[RES.BOARDS] == -2

	# Save all production process for later
	expected_consumed_res = production_line.consumed_res
	expected_produced_res = production_line.produced_res
	expected_production = production_line.production
	expected_progress = production.progress

	# Make sure the producer used the boards
	assert bb_storage.inventory[RES.BOARDS] == 0

	# Save and reload game
	session = saveload(session)
	loadedbb = WorldObject.get_object_by_id(worldid)

	production_loaded = loadedbb.get_component(Producer)._productions[PRODUCTIONLINES.HUKER]
	production_line_loaded = production_loaded._prod_line

	# Make sure everything is loaded correctly
	assert expected_consumed_res == production_line_loaded.consumed_res
	assert expected_produced_res == production_line_loaded.produced_res
	assert expected_production == production_line_loaded.production
	assert expected_progress == production_loaded.progress

	# if you don't let the session run for a bit then collectors won't be fully initialized and can't be killed => another test will fail in session.end()
	session.run(seconds=1)
	session.end()
def test_ticket_1847(s, p):
	"""Tearing down MineProducer (clay pit, mine) crashes game"""
	settlement, island = settle(s)

	assert Build(BUILDINGS.CLAY_DEPOSIT, 30, 30, island, ownerless=True)(None)
	claypit = Build(BUILDINGS.CLAY_PIT, 30, 30, island, settlement=settlement)(p)
	assert claypit

	Tear(claypit)(p)

	s.run(seconds=5)
def test_pavilion_production(s, p):
	"""
	Check whether the pavilion produces faith
	"""
	settlement, island = settle(s)
	pavilion = Build(BUILDINGS.PAVILION, 30, 30, island, settlement=settlement)(p)

	assert pavilion
	assert pavilion.get_component(StorageComponent).inventory[RES.FAITH] == 0
	s.run(seconds=30)
	assert pavilion.get_component(StorageComponent).inventory[RES.FAITH]
def test_ticket_1005(s, p):
	settlement, island = settle(s)
	assert len(s.world.ships) == 2

	builder = Build(BUILDINGS.BOATBUILDER_CLASS, 35, 20, island, settlement=settlement)(p)
	builder.inventory.alter(RES.TEXTILE_ID, 5)
	builder.inventory.alter(RES.BOARDS_ID, 4)
	builder.add_production_by_id(15)

	s.run(seconds=130)

	assert len(s.world.ships) == 3
def test_school_production(s, p):
	"""
	Check whether schools produce education
	"""
	settlement, island = settle(s)
	school = Build(BUILDINGS.VILLAGE_SCHOOL, 30, 30, island, settlement=settlement)(p)

	assert school

	assert school.get_component(StorageComponent).inventory[RES.EDUCATION] == 0
	s.run(seconds=30)
	assert school.get_component(StorageComponent).inventory[RES.EDUCATION]
def test_ticket_1005(s, p):
	settlement, island = settle(s)
	assert len(s.world.ships) == 2

	builder = Build(BUILDINGS.BOAT_BUILDER, 35, 20, island, settlement=settlement)(p)
	builder.get_component(StorageComponent).inventory.alter(RES.TEXTILE, 5)
	builder.get_component(StorageComponent).inventory.alter(RES.BOARDS, 4)
	builder.get_component(Producer).add_production_by_id(15)

	s.run(seconds=130)

	assert len(s.world.ships) == 3
def test_saltpond_production(s, p):
	"""
	Check whether saltponds produce salt
	"""
	settlement, island = settle(s)
	saltpond = Build(BUILDINGS.SALT_PONDS, 25, 20, island, settlement=settlement)(p)

	assert saltpond

	assert saltpond.get_component(StorageComponent).inventory[RES.SALT] == 0
	s.run(seconds=60)
	assert saltpond.get_component(StorageComponent).inventory[RES.SALT] >= 2 # ponds produce salt in units of 2
def test_pavilion_production(s, p):
    """
	Check whether the pavilion produces faith
	"""
    settlement, island = settle(s)
    pavilion = Build(BUILDINGS.PAVILION, 30, 30, island,
                     settlement=settlement)(p)

    assert pavilion
    assert pavilion.get_component(StorageComponent).inventory[RES.FAITH] == 0
    s.run(seconds=30)
    assert pavilion.get_component(StorageComponent).inventory[RES.FAITH]
Exemple #27
0
def test_hunter_save_load():
	"""Save/loading hunter in different states"""
	session, player = new_session()
	settlement, island = settle(session)

	# setup hunter, trees (to keep animals close) and animals

	hunter = Build(BUILDINGS.HUNTER, 30, 30, island, settlement=settlement)(player)
	hunter_worldid = hunter.worldid
	del hunter # invalid after save/load

	for x in xrange(27, 29):
		for y in xrange(25, 28):
			assert Build(BUILDINGS.TREE, x, y, island, settlement=settlement)(player)

	CreateUnit(island.worldid, UNITS.WILD_ANIMAL, 27, 27)(issuer=None)
	CreateUnit(island.worldid, UNITS.WILD_ANIMAL, 28, 27)(issuer=None)
	CreateUnit(island.worldid, UNITS.WILD_ANIMAL, 29, 27)(issuer=None)

	def get_hunter_collector(session):
		hunter = WorldObject.get_object_by_id(hunter_worldid)
		return hunter.get_component(CollectingComponent)._CollectingComponent__collectors[0]

	def await_transition(session, collector, old_state, new_state):
		assert collector.state == old_state, "expected old state %s, got %s" % (old_state, collector.state)
		while collector.state == old_state:
			session.run(seconds=1)
		assert collector.state == new_state, "expected new state %s, got %s" % (old_state, collector.state)


	sequence = [
	  Collector.states.idle,
	  Collector.states.waiting_for_animal_to_stop,
	  Collector.states.moving_to_target,
	  Collector.states.working,
	  Collector.states.moving_home,
	  Collector.states.idle
	  ]

	# do full run without saveload
	collector = get_hunter_collector(session)
	for i in xrange(len(sequence)-1):
		await_transition(session, collector, sequence[i], sequence[i+1])

	# do full run with saveload
	for i in xrange(len(sequence)-1):
		collector = get_hunter_collector(session)
		await_transition(session, collector, sequence[i], sequence[i+1])
		session = saveload(session)

	# last state reached successfully 2 times -> finished
	session.end()
def test_potato_field(s, p):
	"""
	A farm collects potatoes from the field and produces food.
	"""
	settlement, island = settle(s)

	farm = _build_farm(30, 30, BUILDINGS.POTATO_FIELD_CLASS, island, settlement, p)
	assert farm.inventory[RES.FOOD_ID] == 0
	assert farm.inventory[RES.POTATOES_ID] == 0

	s.run(seconds=60)	# potato field 26s, farm 1s

	assert farm.inventory[RES.FOOD_ID]
def test_ticket_1523(s, p):
    settlement, island = settle(s)

    farm = _build_farm(30, 30, BUILDINGS.POTATO_FIELD, island, settlement, p)

    # Let it work for a bit
    s.run(seconds=60)
    assert farm.get_component(StorageComponent).inventory[RES.FOOD]

    assert isinstance(farm.get_component(Producer)._Producer__utilisation, FieldUtilisation)
    # Should be 0.5
    assert not farm.get_component(Producer).capacity_utilisation_below(0.4)
    assert farm.get_component(Producer).capacity_utilisation > 0.4
def test_decommissioned(session, player):
    settlement, island = settle(session)

    lj = Build(BUILDINGS.LUMBERJACK, 30, 30, island, settlement=settlement)(player)

    cb = mock.Mock()
    AddStatusIcon.subscribe(cb)

    assert not cb.called

    ToggleActive(lj.get_component(Producer))(player)

    assert_called_with_icon(cb, DecommissionedStatus)
Exemple #31
0
def test_decommissioned(session, player):
	settlement, island = settle(session)

	lj = Build(BUILDINGS.LUMBERJACK, 30, 30, island, settlement=settlement)(player)

	cb = mock.Mock()
	AddStatusIcon.subscribe(cb)

	assert not cb.called

	ToggleActive(lj.get_component(Producer))(player)

	assert_called_with_icon(cb, DecommissionedStatus)
def test_settler_level_save_load(s, p):
	"""
	Verify that settler level up with save/load works
	"""
	# test all available upgrades: 0->1, 1->2, 2->3...
	for test_level in range(TIER.CURRENT_MAX):
		session, player = new_session()
		settlement, island = settle(s)

		settler = Build(BUILDINGS.RESIDENTIAL, 22, 22, island, settlement=settlement)(p)
		settler.level += test_level
		settler._update_level_data(True, True)
		settler_worldid = settler.worldid

		settlement.tax_settings[settler.level] = -0.5

		# make it happy
		inv = settler.get_component(StorageComponent).inventory
		to_give = inv.get_free_space_for(RES.HAPPINESS)
		inv.alter(RES.HAPPINESS, to_give)
		settler.inhabitants = settler.inhabitants_max
		level = settler.level

		# wait for it to realize it's supposed to upgrade
		s.run(seconds=GAME.INGAME_TICK_INTERVAL)

		assert settler.level == level

		session = saveload(session)
		settler = WorldObject.get_object_by_id(settler_worldid)
		inv = settler.get_component(StorageComponent).inventory

		assert settler.level == level

		# continue
		s.run(seconds=GAME.INGAME_TICK_INTERVAL)

		assert inv[RES.BOARDS] == 0
		assert inv[RES.BRICKS] == 0
		assert settler.level == level
		# give upgrade res
		inv.alter(RES.BOARDS, 100)
		inv.alter(RES.BRICKS, 100)

		# give it max population
		settler.inhabitants = settler.inhabitants_max

		s.run(seconds=GAME.INGAME_TICK_INTERVAL)

		# should have leveled up
		assert settler.level == level + 1
def test_ticket_1561(s, p):
	settlement, island = settle(s)

	residence = Build(BUILDINGS.RESIDENTIAL, 30, 30, island, settlement=settlement)(p)
	s.run(ticks=1)
	assert residence.level == 0

	residence.level_up()
	s.run(ticks=1)
	assert residence.level == 1

	residence2 = Build(BUILDINGS.RESIDENTIAL, 30, 32, island, settlement=settlement)(p)
	s.run(ticks=1)
	assert residence2.level == 0
def test_productivity_low(session, player):
    settlement, island = settle(session)

    Build(BUILDINGS.CHARCOAL_BURNER, 30, 30, island, settlement=settlement)(player)

    cb = mock.Mock()
    AddStatusIcon.subscribe(cb)

    # Not yet low
    assert not cb.called

    session.run(seconds=60)

    # Now low
    assert_called_with_icon(cb, ProductivityLowStatus)
Exemple #35
0
def test_productivity_low(session, player):
	settlement, island = settle(session)

	Build(BUILDINGS.CHARCOAL_BURNER, 30, 30, island, settlement=settlement)(player)

	cb = mock.Mock()
	AddStatusIcon.subscribe(cb)

	# Not yet low
	assert not cb.called

	session.run(seconds=60)

	# Now low
	assert_called_with_icon(cb, ProductivityLowStatus)
def test_distillery(s, p):
	"""
	Distillery produces liquor out of sugar. A farm will collect raw sugar from a
	sugar field and produce sugar.
	"""
	settlement, island = settle(s)

	_build_farm(30, 30, BUILDINGS.SUGARCANE_FIELD_CLASS, island, settlement, p)

	distillery = Build(BUILDINGS.DISTILLERY_CLASS, 27, 30, island, settlement=settlement)(p)
	assert distillery
	assert distillery.inventory[RES.LIQUOR_ID] == 0

	s.run(seconds=60)	# sugarfield 30s, farm 1s, distillery 12s

	assert distillery.inventory[RES.LIQUOR_ID]
def test_weaver(s, p):
	"""
	A weaver produces textiles from wool. A pasture provides lamb wool for a farm,
	which it converts to wool for the weaver.
	"""
	settlement, island = settle(s)

	_build_farm(30, 30, BUILDINGS.PASTURE_CLASS, island, settlement, p)

	weaver = Build(BUILDINGS.WEAVER_CLASS, 27, 30, island, settlement=settlement)(p)
	assert weaver
	assert weaver.inventory[RES.TEXTILE_ID] == 0

	s.run(seconds=60)	# pasture 30s, farm 1s, weaver 12s

	assert weaver.inventory[RES.TEXTILE_ID]
def test_tree_production(s, p):
	"""Check whether trees produce wood"""
	settlement, island = settle(s)
	tree = Build(BUILDINGS.TREE, 30, 35, island, settlement=settlement)(p)

	n = 20

	inv = tree.get_component(StorageComponent).inventory
	for i in xrange(n):  # we want n units

		while not inv[RES.TREES]:
			s.run(seconds=5)

		# take one away to free storage space
		#from tests import set_trace ; set_trace()
		inv.alter(RES.TREES, -1)
def test_school_production(s, p):
    """
	Check whether schools produce education
	"""
    settlement, island = settle(s)
    school = Build(BUILDINGS.VILLAGE_SCHOOL,
                   30,
                   30,
                   island,
                   settlement=settlement)(p)

    assert school

    assert school.get_component(StorageComponent).inventory[RES.EDUCATION] == 0
    s.run(seconds=30)
    assert school.get_component(StorageComponent).inventory[RES.EDUCATION]
def test_brick_production_chain(s, p):
	"""
	A brickyard makes bricks from clay. Clay is collected by a clay pit on a deposit.
	"""
	settlement, island = settle(s)

	assert Build(BUILDINGS.CLAY_DEPOSIT, 30, 30, island, ownerless=True)(None)
	assert Build(BUILDINGS.CLAY_PIT, 30, 30, island, settlement=settlement)(p)

	brickyard = Build(BUILDINGS.BRICKYARD, 30, 25, island, settlement=settlement)(p)
	assert brickyard.get_component(StorageComponent).inventory[RES.BRICKS] == 0
	assert brickyard.get_component(StorageComponent).inventory[RES.CLAY] == 0

	s.run(seconds=60) # 15s clay pit, 15s brickyard

	assert brickyard.get_component(StorageComponent).inventory[RES.BRICKS]
def test_settler_unhappy(session, player):
    settlement, island = settle(session)

    cb = mock.Mock()
    AddStatusIcon.subscribe(cb)

    settler = Build(BUILDINGS.RESIDENTIAL, 30, 30, island, settlement=settlement)(player)

    # certainly not unhappy
    assert settler.happiness > 0.45
    assert not cb.called

    # make it unhappy
    settler.get_component(StorageComponent).inventory.alter(RES.HAPPINESS, -settler.happiness)
    assert settler.happiness < 0.1
    assert_called_with_icon(cb, SettlerUnhappyStatus)