from aot.model.unit import Unit
from aot.model.enums.player import PlayerEnum
from aot.model.enums.sizes import Size
from aot.model.enums.tile import EnumTile
from aot.model.enums.unit import UnitConstant, UnitType
from aot.model.scenario import Scenario
from aot.model.trigger import Trigger
from aot.utilities.configuration import Configuration
import logging
import numpy as np
import random
logging.basicConfig(level=logging.INFO)
C = Configuration("examples/configuration_de.json")
scn = Scenario(size=Size.TINY)
scn.load_template(Size.TINY)
test = Trigger("Build Wonder Time (need change)", enable=1, loop=False)
test.then_(ModifyAttribute(source_player=1))
test.then_(ModifyAttribute(source_player=2))
test.then_(ModifyAttribute(source_player=3))
test.then_(ModifyAttribute(source_player=4))
test.then_(ModifyAttribute(source_player=5))
test.then_(ModifyAttribute(source_player=6))
test.then_(ModifyAttribute(source_player=7))
test.then_(ModifyAttribute(source_player=8))
test.then_(ModifyAttributeCastle(source_player=1))
test.then_(ModifyAttributeCastle(source_player=2))
test.then_(ModifyAttributeCastle(source_player=3))
test.then_(ModifyAttributeCastle(source_player=4))
from aot.model.effect import *
from aot.model.trigger import Trigger
from aot.model.enums.sizes import Size
from aot.model.scenario import Scenario
from aot.utilities.configuration import Configuration
import logging
from test.test_api.compare import compare_scenario_files
logging.basicConfig(level=logging.DEBUG)
C = Configuration("test/dirty_tests/config.json")
scn = Scenario(size=Size.GIANT)
scn.load_template(Size.GIANT)
scn.add(
Trigger("Trigger 0", enable=1).then_(
SendInstruction(message="Hello instruction !!!! (from true file)")))
scn.add(
Trigger("Trigger 1", enable=1).then_(
SendInstruction(message="Hello instruction 2 !!!! (from true file)")))
scn.save(C.game_path_scenario, "test_instruction_from_scratch")
copy = Scenario(size=Size.GIANT)
copy.load(C.game_path_scenario, "test_instruction_from_scratch")
true = Scenario(size=Size.GIANT)
true.load(C.game_path_scenario, "hello_instruction")
compare_scenario_files(copy, true, header=True)
compare_scenario_files(copy, true, header=False)
from aot.model.enums.sizes import Size
from aot.model.scenario import Scenario
from aot.utilities.configuration import Configuration
import logging
from test.test_api.compare import compare_scenario_files
logger = logging.getLogger(__name__)
C = Configuration("config.json")
logging.basicConfig(level=logging.DEBUG)
copy = Scenario(size=Size.GIANT)
copy.load(C.game_path_scenario, "test_display_instruction")
copy.save(C.game_path_scenario, "test_display_instruction_copy")
true = Scenario(size=Size.GIANT)
true.load(C.game_path_scenario, "test_display_instruction")
copy = Scenario(size=Size.GIANT)
copy.load(C.game_path_scenario, "test_display_instruction_copy")
print(compare_scenario_files(copy, true, header=True))
print(compare_scenario_files(copy, true, header=False))
from aot.model.enums.sizes import Size
from aot.model.scenario import Scenario
from aot.utilities.configuration import Configuration
from aot.model.enums import constants
import logging
basename = "fresh_scenario"
#basename = "fresh_scenario2"
basename = "fresh_scenario3"
basename = "large"
basename = "debug_de"
basename = "large2"
basename = "template_small"
C = Configuration("test/dirty_tests/config.json")
logging.basicConfig(level=logging.DEBUG)
scn = Scenario()
scn.load(C.game_path_scenario, basename)
from aot.model.condition import *
from aot.model.effect import *
from aot.model.enums.player import PlayerEnum
from aot.model.enums.sizes import Size
from aot.model.enums.tile import EnumTile
from aot.model.enums.unit import UnitConstant, UnitType
from aot.model.scenario import Scenario
from aot.model.trigger import Trigger
from aot.utilities.configuration import Configuration
import logging
import numpy as np
logging.basicConfig(level=logging.DEBUG)
C = Configuration("examples/configuration_de.json")
scn = Scenario(size=Size.NORMAL)
# scn.load(C.game_path_scenario, "template-aotw")
scn.load_template(Size.NORMAL)
#
TIME_TO_TRAIN_UNITS = 150
NUMBER_OF_MESSAGES_OPEN_AREA_COUNTDOWN = int(
TIME_TO_TRAIN_UNITS / 5) # int(TIME_TO_TRAIN_UNITS / 20)
MAX_TIME_OF_A_ROUND = 600
EXTRA_POPULATION = 60
WIN_AREA_POSITION_RELATIVE_TO_SPAWN = 15
SPAWN_LENGTH = 50
GOLD = 10000
FOOD = 10000
STONE = 0
WOOD = 10000
NUMBER_OF_WARNING = 10
import numpy as np
import logging
from aot.model.scenario import Scenario
from aot.model.unit import Unit
from aot.meta_triggers.metatrigger_treasure import TreasureLoot, TreasureQuarry, TreasureLumber
from aot.utilities.configuration import Configuration
logging.basicConfig(level=logging.DEBUG)
C = Configuration("examples\configuration_de.json")
scn = Scenario()
for _ in range(100):
n = np.random.random()
x = int(np.random.random() * scn.get_width())
y = int(np.random.random() * scn.get_height())
if n < 0.33:
treasure = TreasureLoot(x, y, 500)
elif n < 0.66:
treasure = TreasureLumber(x, y, 500)
else:
treasure = TreasureQuarry(x, y, 500)
scn.add(treasure)
scn.save(C.game_path_scenario, "random_tresures")
from aot.model.enums import constants
import logging
from test.test_api.compare import compare_scenario_files
import logging
import os
logger = logging.getLogger(__name__)
C = Configuration("config.json")
# basename = "fresh"
basename = "debug_de"
logging.basicConfig(level=logging.DEBUG)
true = Scenario( size=Size.GIANT)
true.load("../scenarios", basename, "../tmp/true.header", "../tmp/true.decompressed")
true.save("../tmp", basename, change_timestamp=False)
true.save(C.game_path_scenario, basename + "_tmp", change_timestamp=True)
copy = Scenario(size=Size.GIANT)
copy.load("../tmp", basename, "../tmp/copy.header", "../tmp/copy.decompressed")
differences = compare_scenario_files(copy, true, header=True)
assert len(differences) == 0, "Variables from HEADER are different for those keys " + str(differences)
print("[OK] Variables header")
differences = compare_scenario_files(copy, true)
assert len(differences) == 0, "Variables are different for those keys " + str(differences)
from aot.model.enums.sizes import Size
from aot.model.scenario import Scenario
from aot.utilities.configuration import Configuration
from aot.model.enums import constants
import logging
from test.test_api.compare import compare_scenario_files
import logging
import os
logger = logging.getLogger(__name__)
C = Configuration("config.json")
# basename = "fresh"
logging.basicConfig(level=logging.DEBUG)
# true = Scenario( size=Size.GIANT)
# true.load(C.game_path_scenario, "age-of-total-war 0.02")
copy = Scenario(size=Size.GIANT)
copy.load(C.game_path_scenario, "age-of-total-war xaxa")
# differences = compare_scenario_files(copy, true, header=True)
# print(differences)
# differences = compare_scenario_files(copy, true)
# print(differences)
from aot.meta_triggers.DisplayInstructions import DisplayInstructions, InstructionParameters
from aot.meta_triggers.invicible_unit import InvicibleUnit
from aot.meta_triggers.no_house_needed import NoHouseNeeded
from aot.model.condition import *
from aot.model.effect import *
from aot.model.unit import Unit
from aot.model.enums.player import PlayerEnum
from aot.model.enums.sizes import Size
from aot.model.enums.tile import EnumTile
from aot.model.enums.unit import UnitConstant, UnitType
from aot.model.scenario import Scenario
from aot.model.trigger import Trigger
from aot.utilities.configuration import Configuration
import logging
import numpy as np
import random
logging.basicConfig(level=logging.INFO)
C = Configuration("examples/configuration_de.json")
scn = Scenario(size=Size.TINY)
scn.load(
path="templates",
basename="template_tiny",
path_header=
"C:/Users/cheung/Documents/age-of-triggers/templates/header/text.txt",
path_decompressed_data=
"C:/Users/cheung/Documents/age-of-triggers/templates/decompressed_data/text.txt"
)
def generate_black_and_white_from_png(use_beaches,
use_gradients,
png_img,
path,
basename,
size=Size.GIANT,
rotation=0):
print(PIL.PILLOW_VERSION)
scn = Scenario(size=size)
img = Image.open(png_img)
img = img.convert('L')
img = img.point(lambda x: 0 if x < 128 else 255, '1')
img = img.resize((scn.map.width, scn.map.height), Image.ANTIALIAS)
img = img.transpose(Image.FLIP_TOP_BOTTOM)
img = ImageOps.invert(img.convert("RGB")).convert('1')
img = img.rotate(rotation)
for x in range(img.size[0]):
for y in range(img.size[1]):
is_black = img.getpixel((x, y)) == 0
if is_black:
scn.map.tiles[x][y].type = 22
if use_beaches is True:
erosion_img = img.filter(ImageFilter.MinFilter(3))
for _ in range(1):
erosion_img = erosion_img.filter(ImageFilter.MinFilter(3))
beaches = ImageChops.subtract(img, erosion_img)
# beaches.show()
for x in range(img.size[0]):
for y in range(img.size[1]):
is_white = beaches.getpixel((x, y)) == 255
if is_white:
scn.map.tiles[x][y].type = 2
if use_gradients is True: # to avoid any other type of stuff
# inverted.show()
dilation_img_for_azure = img.filter(ImageFilter.MaxFilter(3))
for _ in range(7):
dilation_img_for_azure = dilation_img_for_azure.filter(
ImageFilter.MaxFilter(3))
azure_water = ImageChops.subtract(dilation_img_for_azure, img)
# azure_water.show()
for x in range(img.size[0]):
for y in range(img.size[1]):
is_white = azure_water.getpixel((x, y)) == 255
if is_white:
scn.map.tiles[x][y].type = 1
dilation_img_for_medium = dilation_img_for_azure.filter(
ImageFilter.MaxFilter(3))
for _ in range(7):
dilation_img_for_medium = dilation_img_for_medium.filter(
ImageFilter.MaxFilter(3))
medium_water = ImageChops.subtract(dilation_img_for_medium,
dilation_img_for_azure)
for x in range(img.size[0]):
for y in range(img.size[1]):
is_white = medium_water.getpixel((x, y)) == 255
if is_white:
scn.map.tiles[x][y].type = 23
scn.save(path, basename)
import logging
from test.test_api.compare import compare_scenario_files
import logging
import os
logger = logging.getLogger(__name__)
C = Configuration("config.json")
#basename = "debug_de"
#basename = "fresh_scenario"
basename = "fresh"
logging.basicConfig(level=logging.DEBUG)
scn = Scenario(header_type=constants.HT_AOE2_DE, size=Size.GIANT)
scn.load(C.game_path_scenario, basename)
scn.save("../tmp", basename)
scn_to_check = Scenario(header_type=constants.HT_AOE2_DE, size=Size.GIANT)
scn_to_check.load("../tmp", basename, path_decompressed_data="../tmp/copy.decompressed")
true_scn = Scenario(header_type=constants.HT_AOE2_DE, size=Size.GIANT)
true_scn.load(C.game_path_scenario, basename, path_decompressed_data="../tmp/true.decompressed")
logger.debug("---------------------------------------")
logger.debug("---------------------------------------")
logger.debug("---------------------------------------")
logger.debug("---------------------------------------")
copy_size = os.path.getsize("../tmp/copy.decompressed")