def setUp(self):
super().setUp()
self.game = Game()
self.board = self.game.load_board("hac-maps/kneighbors.json", 1)
self.game.player = Player(name="player")
self.game.change_level(1)
self.tree26 = self.board.item(2, 6)
self.treasure38 = self.board.item(3, 8)
self.tree39 = self.board.item(3, 9)
self.wall45 = self.board.item(4, 5)
self.wall46 = self.board.item(4, 6)
self.wall47 = self.board.item(4, 7)
self.wall57 = self.board.item(5, 7)
self.npc77 = self.board.item(7, 7)
self.treasure1212 = self.board.item(12, 12)
self.tree1310 = self.board.item(13, 10)
self.npc168 = self.board.item(16, 8)
def make_platform(b, row, column):
psize = random.randint(2, 10)
plateform = []
tmp_game = Game()
# Only because Game needs it, we don't care.
tmp_game.player = Player()
tmp_game.add_board(0, b)
tmp_game.change_level(0)
# print(
# f"[d] make_platform at {row}, {column}, psize is {psize} column will be "
# f"between {column} and {column + psize + 1}"
# )
get_up = 0
# for i in range(column, column + psize + 1):
for i in range(column - psize - 1, column):
if i >= b.size[0]:
break
if not isinstance(b.item(row, i), BoardItemVoid):
break
if i in b.visited_columns:
break
# Check if we have other platforms around.
# If yes moving the platform up.
if get_up < 3:
for e in tmp_game.neighbors(2, Door(pos=[row, i])):
if e.type == "ground":
get_up = 3
break
if get_up < 4:
for e in tmp_game.neighbors(1, Door(pos=[row, i])):
if e.type == "ground":
get_up = 4
break
m = block_color() + " " + Utils.Style.RESET_ALL
plateform.append([Wall(model=m, type="platform"), row, i])
for i in plateform:
b.place_item(i[0], i[1] - get_up, i[2])
if random.choice([True, False]):
generate_treasure(b, i[1] - get_up - 1, i[2])
else:
generate_trap(b, i[1] - get_up - 1, i[2])
b.visited_columns.append(i[2])
import gamelib.Utils as Utils
import time
import sys
# Destination 17,12
dest_row = 24
dest_col = 24
if len(sys.argv) > 1:
dest_row = int(sys.argv[1])
if len(sys.argv) > 2:
dest_col = int(sys.argv[2])
print(f'dest_row={dest_row} dest_col={dest_col}')
g = Game()
# b = g.load_board('hac-maps/Debug_board.json',1)
# b = g.load_board('hac-maps/PathFinding.json',1)
b = g.load_board('hac-maps/Maze.json',1)
g.player = Player(name='The Mighty Wizard',model=Sprites.MAGE)
g.change_level(1)
g.actuate_npcs(1)
pf = PathFinder(game=g,actuated_object=g.player)
pf.set_destination(dest_row,dest_col)
path = pf.find_path()
print("Path found:")
print(path)
for (r,c) in path:
print(Utils.blue_bright("\t\tNew board"))
print("First we need some information on your new board:")
name = str(input('Name: '))
width = int(input_digit('Width (in number of cells): '))
height = int(input_digit('Height (in number of cells): '))
game.add_board(
1,
Board(name=name,
size=[width, height],
ui_borders=Utils.WHITE_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE))
is_modified = True
# Main program
game = Game()
current_file = ''
game.player = Player(model='[]')
key = 'None'
current_object = BoardItemVoid(model='None')
object_history = []
current_menu = 'main'
while True:
game.clear_screen()
print(
Utils.cyan_bright("HAC-GAME-LIB - EDITOR v" +
Constants.HAC_GAME_LIB_VERSION))
print('Looking for existing maps in selected directories...', end='')
with open('directories.json') as paths:
directories = json.load(paths)
for c in range(dg.width):
if dg.dungeon[r][c].get_ch() == "#":
random_board.place_item(Wall(model=Sprites.WALL), r, c)
elif dg.dungeon[r][c].get_ch() == "+":
random_board.place_item(Door(model=Sprites.DOOR), r, c)
elif dg.dungeon[r][c].get_ch() == ".":
potential_starting_position.append([r, c])
random_board.player_starting_position = choice(potential_starting_position)
print("done")
print(f"starting position chosen: {random_board.player_starting_position}")
# dg.print_map()
# random_board.display()
input("New random dungeon generated. Next?")
g = Game()
g.enable_partial_display = True
# g.load_board('/home/arnaud/Code/Games/hgl-editor/Large_Dungeon.json', 1)
g.player = Player(model=Sprites.MAGE)
g.add_board(1, random_board)
g.change_level(1)
key = None
viewport = [10, 10]
g.partial_display_viewport = viewport
while True:
if key == "Q":
break
elif key == "S":
g.save_board(1, f"random-dungeon-{randrange(1000,9999)}.json")
elif key == "1":
from gamelib.Game import Game
g = Game()
c = g.load_config("test-config.json", "test")
print(f"Version: {g.config('test')['config_file_version']}")
g.config("test")["directories"].append("test_boards")
g.save_config("test", "config-test.json")
print(g.config("blorp"))
from gamelib.Game import Game
from gamelib.Board import Board
import gamelib.Utils as Utils
import gamelib.Sprites as Sprites
import gamelib.Constants as Constants
from gamelib.Characters import Player
import time
mygame = Game(name='Demo Game')
board1 = Board(name='Level 1',
ui_borders=Sprites.WALL,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[0, 0])
board2 = Board(name='Level 2',
ui_borders=Utils.RED_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[4, 4])
mygame.player = Player(name='DaPlay3r', model=Sprites.UNICORN_FACE)
mygame.add_board(1, board1)
mygame.add_board(2, board2)
mygame.change_level(1)
key = None
# Main game loop
while True:
mygame.clear_screen()
mygame.display_board()
from gamelib.Board import Board
import gamelib.Utils as Utils
import gamelib.Sprites as Sprites
from gamelib.Characters import Player
import time
#################################################################################
## ##
## IMPORTANT NOTE: ##
## ##
## The companion article for this tutorial code is at: ##
## https://astro.hyrul.es/guides/hac-game-lib/tutorial-01-the-game-object.html ##
## ##
#################################################################################
mygame = Game(name='Demo game')
board1 = Board(name='Level 1',
ui_borders=Sprites.WALL,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[0, 0])
board2 = Board(name='Level 2',
ui_borders=Utils.RED_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[4, 4])
mygame.player = Player(name='DaPlay3r', model=Sprites.UNICORN_FACE)
mygame.add_board(1, board1)
mygame.add_board(2, board2)
count = 0
import gamelib.Sprites as Sprites
import gamelib.Constants as Constants
import gamelib.Utils as Utils
import time
import sys
board_to_load = 'hac-maps/test-board.json'
if len(sys.argv) > 1:
board_to_load = sys.argv[1]
max_iter = 10
if len(sys.argv) > 2:
max_iter = int(sys.argv[2])
g = Game()
b = g.load_board(board_to_load, 1)
print(b)
g.player = Player(model=Sprites.FLYING_SAUCER)
g.change_level(1)
idx = 0
key = None
while idx < max_iter or max_iter == 0:
if key == 'w':
g.move_player(Constants.UP, 1)
elif key == 's':
global g
for i in g.current_board().get_immovables(type='path_marker'):
g.current_board().place_item(BoardItemVoid(), i.pos[0], i.pos[1])
# Destination (24,24) is the center of the labyrinth
dest_row = 24
dest_col = 24
if len(sys.argv) > 1:
dest_row = int(sys.argv[1])
if len(sys.argv) > 2:
dest_col = int(sys.argv[2])
g = Game()
b = g.load_board('hac-maps/Maze.json', 1)
g.player = Player(name='The Mighty Wizard', model=Sprites.MAGE)
g.change_level(1)
g.actuate_npcs(1)
pf = PathFinder(game=g, actuated_object=g.player)
pf.add_waypoint(dest_row, dest_col)
pf.add_waypoint(24, 24)
pf.add_waypoint(21, 40)
pf.circle_waypoints = True
pf.set_destination(dest_row, dest_col)
": I am so lonely, if only I had an aquatic friend to play with..."
)
# The board we want to load for the first level
level_1 = 'levels/TutoMap-hac-game-lib.json'
# And the game over screen
game_over = 'levels/Game_Over.json'
# The notifications are going to be used to give info to the player without entering a full dialog mode.
# IMPORTANT: The player movement clears the notifications not the rest of the game. As we are going to multithread the game at some point it's important to take the right decision from start.
notifications = []
# Create the game object. We are going to use this as a global variable.
g = Game()
# Load the board as level 1
b = g.load_board(level_1, 1)
# The game over screen is going to be level 999. There is no reason for that, it is just a convention as I don't think that this game is going to have more than 998 levels.
g.load_board(game_over, 999)
# Create the player object.
g.player = Player(name='The Mighty Wizard', model=Sprites.MAGE)
g.change_level(1)
# Now we need to fix the river (it's missing 2 tiles of water)
# First let's move the NPCs so the whales are not replaced by our new tiles.
g.actuate_npcs(1)
# Now let's place the 2 river tiles (we use the Door object as a shortcut to get a overlapable, restorable item)
g.current_board().place_item(Door(model=Utils.BLUE_SQUARE), 0, 26)
default_map_dir, "hac-maps", "maps"
]
game.config("settings")["config_file_version"] = 10100
game.config("settings")["enable_partial_display"] = True
game.config("settings")["partial_display_viewport"] = [10, 30]
game.config("settings")["menu_mode"] = "full"
game.config("settings")["last_used_board_parameters"] = {
"name": None,
"width": None,
"height": None,
}
game.config("settings")["object_library"] = []
# Main program
game = Game()
current_file = ""
game.player = Player(model="[]")
key = "None"
current_object = BoardItemVoid(model="None")
current_object_instance = BoardItemVoid(model="None")
object_history = []
viewport_board = Board(
name="Viewport testing board",
size=[viewport_width * 2, viewport_height * 2],
ui_borders=Utils.GREEN_SQUARE,
ui_board_void_cell=Utils.RED_SQUARE,
)
game.add_board(2, viewport_board)
current_menu = "main"
while True:
sum_dc = eucli_dist
# print(
# f"Updating winner with {winner} and deltas {dc_r},{dc_c} "
# f"and sum_dc = {sum_dc}"
# )
if DEBUG:
reset_drawn_path()
g.current_board().place_item(
Door(model=Utils.GREEN_SQUARE, type="path_marker"), winner[0],
winner[1])
redraw()
# input(f'Winner: {winner}')
return winner
g = Game()
# b = g.load_board('/home/arnaud/Code/Games/hgl-editor/TestChasing.json', 1)
b = g.load_board("hac-maps/The_Castle.json", 1)
g.player = Player(name="The Mighty Wizard", model=Sprites.MAGE)
g.change_level(1)
guards = []
for item in g.current_board().get_movables(type="guard"):
guards.append(item)
nm = None
key = None
chasing = False
g.actuate_projectiles(1)
g.animate_items(1)
time.sleep(0.1)
game_running = True
b = Board(
ui_borders=Graphics.WHITE_SQUARE,
ui_board_void_cell=Graphics.BLACK_SQUARE,
size=[20, 20],
player_starting_position=[5, 5],
)
wall = Wall(model=Graphics.Sprites.BRICK)
b.place_item(wall, 1, 6)
b.place_item(wall, 5, 10)
g = Game()
g.add_board(1, b)
g.player = Player(model=Graphics.Sprites.MAGE)
g.player.level = 1
g.player.mp = 20
g.player.max_mp = 20
g.add_npc(
1,
NPC(
name="Bob Soontobedead",
model=Graphics.Sprites.SKULL,
hp=10,
actuator=RandomActuator(moveset=[Constants.NO_DIR]),
),
6,
d.animation = a
# Finally place the water on the board
b.place_item(d, r, c)
# Redraw the screen and wait to see the nice animation of the algorithm working.
# Otherwise it's instantanous.
redraw_screen(g)
time.sleep(0.1)
# Now make recursive calls to fill the cells around this one.
flood_filler(g, b, r + 1, c)
flood_filler(g, b, r - 1, c)
flood_filler(g, b, r, c + 1)
flood_filler(g, b, r, c - 1)
# Using the Game object just to load the board easily
g = Game()
b = g.load_board("/home/arnaud/Code/Games/hgl-editor/Filler.json", 1)
g.player = Player(model=Graphics.Sprites.MAGE)
g.change_level(1)
# We need the player out of our way
g.move_player(Constants.LEFT, 5)
# Now let's flood the floor!!
flood_filler(g, b, 5, 6)
# Show the animated lake for 200 turns (~40 secondes)
i = 0
while i < 200:
i += 1
redraw_screen(g)
g.animate_items(1)
lvl1 = Board(ui_borders=Utils.CYAN_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[0, 0])
# On that board the player starts at the center
lvl2 = Board(ui_borders=Utils.MAGENTA_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[5, 5])
# And on that board the player starts at the bottom right corner
lvl3 = Board(ui_borders=Utils.RED_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[9, 9])
# Now let's create a game object.
mygame = Game(name='demo')
# And a Player
nazbrok = Player(name='Nazbrok', model=Utils.green_bright("¤¤"))
# Now add the boards to the game so the Game object can manage them
# the parameters of add_board() are a level number and a board.
mygame.add_board(1, lvl1)
mygame.add_board(2, lvl2)
mygame.add_board(3, lvl3)
# Now we also want our player to be managed by the game
mygame.player = nazbrok
# Now let's show a clean screen to our player
mygame.clear_screen()
ui_border_bottom=Utils.WHITE_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[10, 20],
)
lvl2 = Board(
name='Level_2',
size=[40, 20],
ui_border_left=Utils.WHITE_SQUARE,
ui_border_right=Utils.WHITE_SQUARE,
ui_border_top=Utils.WHITE_SQUARE,
ui_border_bottom=Utils.WHITE_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE,
player_starting_position=[0, 0],
)
game = Game(name='HAC Game')
p = Player(model=sprite_player['right'], name='Nazbrok')
npc1 = NPC(model=sprite_npc, name='Bad guy 1', step=1)
# Test of the PathActuator
npc1.actuator = PathActuator(path=[
cst.UP, cst.UP, cst.UP, cst.UP, cst.UP, cst.UP, cst.UP, cst.UP, cst.RIGHT,
cst.RIGHT, cst.RIGHT, cst.RIGHT, cst.DOWN, cst.DOWN, cst.DOWN, cst.DOWN,
cst.DOWN, cst.DOWN, cst.DOWN, cst.DOWN, cst.LEFT, cst.LEFT, cst.LEFT,
cst.LEFT
])
game.add_board(1, lvl1)
game.add_board(2, lvl2)
t = Treasure(model=sprite_treasure, name='Cool treasure', type='gem')
money_bag = Treasure(model=sprite_treasure2, name='money', value=20)
from gamelib.Board import Board
from gamelib.Characters import Player, Vehicle
from gamelib.Game import Game
import gamelib.Utils as Utils
import gamelib.Constants as Constants
g = Game()
g.player = Player(model="\u232C")
b = Board(size=[80, 50])
mod_right = [["\u25E3", " "], ["\u25A2", "\u25D7"], ["\u25E4", " "]]
mod_left = [["\u25E2"], ["\u25D6", "\u25A2"], ["\u25E2"]]
mi = Vehicle(model=mod_right)
g.add_board(1, b)
g.change_level(1)
g.current_board().place_item(mi, 20, 20)
key = None
while True:
if key == Utils.key.UP:
g.current_board().move(mi, Constants.UP, 1)
elif key == Utils.key.DOWN:
g.current_board().move(mi, Constants.DOWN, 1)
elif key == Utils.key.LEFT:
# mi.update_model(mod_left)
g.current_board().move(mi, Constants.LEFT, 1)
elif key == Utils.key.RIGHT:
# mi.update_model(mod_right)
g.current_board().move(mi, Constants.RIGHT, 1)
from gamelib.Game import Game
from gamelib.Board import Board
from gamelib.Characters import Player, NPC
from gamelib.Structures import Door, Treasure
from gamelib.BoardItem import BoardItemVoid
import gamelib.Sprites as Sprites
import gamelib.Constants as Constants
import gamelib.Utils as Utils
import time
import random
## Here are our global variables (it is usually a bad idea to use global variables but it will simplify that tutorial, keep in mind that we don't usually rely on global variables)
# Create the game object. We are going to use this as a global variable.
g = Game()
# Load the board as level 1
b = g.load_board('levels/TutoMap-hac-game-lib.json', 1)
def refresh_screen():
global g
g.clear_screen()
g.display_player_stats()
g.display_board()
def damage_player(params):
pass
# IMPORTANT: The player movement clears the notifications not the rest of the game. As
# we are going to multithread the game at some point it's important to take the right
# decision from start.
notifications = []
# Now create a variable to hold the current menu.
current_menu = "default"
# We also need to keep track of how much gold was given to the fairy
fairy_gold = 0
# We will need to keep a counter for the number of turns left in level 2
level_2_turns_left = 21
# Create the game object. We are going to use this as a global variable.
g = Game()
def print_animated(message):
for line in message:
print(line, end="", flush=True)
if line == "\n":
time.sleep(1)
else:
time.sleep(0.1)
def introduction_scene():
intro_dialog = (
f"{Sprites.MAGE}: Hu... Where am I?\n"
f"{Sprites.UNICORN_FACE}: Welcome Mighty Wizard!\n"
nb_blocks = int((g.player.mp / g.player.max_mp) * 20)
print("Mana [" + Utils.BLUE_RECT * nb_blocks + Utils.BLACK_RECT *
(20 - nb_blocks) + "]")
g.display_board()
# manage_fireballs()
b = Board(
ui_borders=Utils.WHITE_SQUARE,
ui_board_void_cell=Utils.BLACK_SQUARE,
size=[20, 20],
player_starting_position=[5, 5],
)
wall = Wall(model=Sprites.WALL)
b.place_item(wall, 1, 6)
g = Game()
g.add_board(1, b)
g.player = Player(model=Sprites.MAGE, name="The Maje")
g.player.mp = 20
g.player.max_mp = 20
g.change_level(1)
key = None
black_circle = "-\U000025CF"
circle_jot = "-\U0000233E"
throw_fireball = False
projectile = Projectile()
while True:
if key == "Q":
global term, term_res
if term.width >= 140:
term_res = 140
else:
term_res = 80
g.partial_display_viewport = [10, int(term_res / 4)]
# We need the hac-game-lib v1.1+
if Constants.HAC_GAME_LIB_VERSION < "1.1.0":
Utils.print_white_on_red(
"Super Panda Run EX require the hac-game-lib version 1.1.0 or greater."
f" Version installed is {Constants.HAC_GAME_LIB_VERSION}")
raise SystemExit()
g = Game()
g.enable_partial_display = True
g.partial_display_viewport = [10, int(term_res / 4)]
g.current_level = 0
g.player = Player(model=bg_color + Graphics.Sprites.PANDA +
Graphics.Style.RESET_ALL)
g.player.name = "Zigomar"
g.player.max_y = g.player.pos[0]
g.player.dy = gravity_speed
g.player.last_y = g.player.pos[0]
g.player.last_x = g.player.pos[1]
g.timer = 60
g.score = 0
g.obj_stack = []
g.pause()
import examples_includes # noqa: F401
# For this example we need to import Game, Board, Utils and Player
from gamelib.Game import Game
import gamelib.Utils as Utils
# First of all let's create a Game object
mygame = Game(name="Demo game")
# Set a message variable to display a message on selected menu item
message = None
# Now we want to create some menus to tell the player what to do, or to
# give some informations/directions
# IMPORTANT: Menu do absolutely nothing by themselves, they are just a
# structured display of informations.
# The syntaxe is game_object.add_menu_entry(category,shortcut,message)
option_red = "A cool menu in dim red"
option_magenta = "Another cool menu in bright magenta"
mygame.add_menu_entry("main_menu", None, "=" * 22)
mygame.add_menu_entry("main_menu", "h", "Show the help menu")
mygame.add_menu_entry("main_menu", None, "=" * 22)
mygame.add_menu_entry("main_menu", "1", Utils.red_dim(option_red))
mygame.add_menu_entry("main_menu", "2", Utils.magenta_bright(option_magenta))
mygame.add_menu_entry("main_menu", "q", "Quit game")
mygame.add_menu_entry("help_menu", None, "---------")
mygame.add_menu_entry("help_menu", None, "Help Menu")
mygame.add_menu_entry("help_menu", None, "---------")
mygame.add_menu_entry("help_menu", "j", "Random help menu")
mygame.add_menu_entry("help_menu", "b", "Back to main menu")
# The notifications are going to be used to give info to the player without entering a full dialog mode.
# IMPORTANT: The player movement clears the notifications not the rest of the game. As we are going to multithread the game at some point it's important to take the right decision from start.
notifications = []
# Now create a variable to hold the current menu.
current_menu = 'default'
# We also need to keep track of how much gold was given to the fairy
fairy_gold = 0
# We will need to keep a counter for the number of turns left in level 2
level_2_turns_left = 21
# Create the game object. We are going to use this as a global variable.
g = Game()
def print_animated(message):
for l in message:
print(l,end='', flush=True)
if l == '\n':
time.sleep(1)
else:
time.sleep(0.1)
def introduction_scene():
intro_dialog = f"{Sprites.MAGE}: Hu... Where am I?\n{Sprites.UNICORN_FACE}: Welcome Mighty Wizard!\n{Sprites.UNICORN_FACE}: Your help is needed to bring balance to the wildlife of this world.\n{Sprites.UNICORN_FACE}: Only then will you be able to ask the portal fairy to open the portal to continue your journey.\n{Sprites.UNICORN_FACE}: Good luck!\n{Sprites.MAGE}: Ok then, let's go!"
g.clear_screen()
print_animated(intro_dialog)
from gamelib.Game import Game
from gamelib.Characters import Player
import gamelib.Sprites as Sprites
import gamelib.Utils as Utils
import gamelib.Constants as Constants
g = Game()
b = g.load_board('hac-maps/kneighbors.json',1)
g.player = Player(model=Sprites.FLYING_SAUCER,name='player')
g.change_level(1)
key = None
while True:
if key == 'w':
g.move_player(Constants.UP,1)
elif key == 's':
g.move_player(Constants.DOWN,1)
elif key == 'a':
g.move_player(Constants.LEFT,1)
elif key == 'd':
g.move_player(Constants.RIGHT,1)
elif key == 'q':
break
g.clear_screen()
g.display_board()
for i in g.neighbors(1):
print(f'Player: {i.name} ({i.pos[0]},{i.pos[1]})')
import examples_includes
# For this example we need to import Game, Board, Utils and Player
from gamelib.Game import Game
import gamelib.Utils as Utils
# First of all let's create a Game object
mygame = Game(name='Demo game')
# Set a message variable to display a message on selected menu item
message = None
# Now we want to create some menus to tell the player what to do, or to give some informations/directions
# IMPORTANT: Menu do absolutely nothing by themselves, they are just a structured display of informations
# The syntaxe is game_object.add_menu_entry(category,shortcut,message)
mygame.add_menu_entry('main_menu', None, '=' * 22)
mygame.add_menu_entry('main_menu', 'h', 'Show the help menu')
mygame.add_menu_entry('main_menu', None, '=' * 22)
mygame.add_menu_entry('main_menu', '1',
Utils.red_dim('A cool menu in dim red'))
mygame.add_menu_entry(
'main_menu', '2',
Utils.magenta_bright('Another cool menu in bright magenta'))
mygame.add_menu_entry('main_menu', 'q', 'Quit game')
mygame.add_menu_entry('help_menu', None, '---------')
mygame.add_menu_entry('help_menu', None, 'Help Menu')
mygame.add_menu_entry('help_menu', None, '---------')
mygame.add_menu_entry('help_menu', 'j', 'Random help menu')
mygame.add_menu_entry('help_menu', 'b', 'Back to main menu')
# let's set a variable that hold the current menu category (for navigation)
global g
g.clear_screen()
g.display_board()
# Destination (24,24) is the center of the labyrinth
dest_row = 24
dest_col = 24
if len(sys.argv) > 1:
dest_row = int(sys.argv[1])
if len(sys.argv) > 2:
dest_col = int(sys.argv[2])
g = Game()
b = g.load_board('hac-maps/Maze.json', 1)
g.player = Player(name='The Mighty Wizard', model=Sprites.MAGE)
g.change_level(1)
g.actuate_npcs(1)
pf = PathFinder(game=g, actuated_object=g.player)
pf.add_waypoint(dest_row, dest_col)
pf.add_waypoint(24, 24)
pf.add_waypoint(21, 40)
pf.circle_waypoints = True
pf.set_destination(dest_row, dest_col)
class GameNeighborTestCase(unittest.TestCase):
def setUp(self):
super().setUp()
self.game = Game()
self.board = self.game.load_board("hac-maps/kneighbors.json", 1)
self.game.player = Player(name="player")
self.game.change_level(1)
self.tree26 = self.board.item(2, 6)
self.treasure38 = self.board.item(3, 8)
self.tree39 = self.board.item(3, 9)
self.wall45 = self.board.item(4, 5)
self.wall46 = self.board.item(4, 6)
self.wall47 = self.board.item(4, 7)
self.wall57 = self.board.item(5, 7)
self.npc77 = self.board.item(7, 7)
self.treasure1212 = self.board.item(12, 12)
self.tree1310 = self.board.item(13, 10)
self.npc168 = self.board.item(16, 8)
def test_player_neighbors(self):
testcases = (
([3, 3], []),
([3, 5], [self.tree26, self.wall45, self.wall46]),
([3, 6], [self.tree26, self.wall45, self.wall46, self.wall47]),
([3, 7], [self.tree26, self.wall46, self.wall47, self.treasure38]),
([4, 8], [self.wall47, self.wall57, self.treasure38, self.tree39]),
([5, 6], [self.wall45, self.wall46, self.wall47, self.wall57]),
)
for pos, expected_board_items in testcases:
with self.subTest(str(pos)):
self.game.player.pos = pos
actual_board_items = self.game.neighbors()
assertion_message = " ".join([
readable_board_items(expected_board_items),
"!=",
readable_board_items(actual_board_items),
])
self.assertSetEqual(
set(expected_board_items),
set(actual_board_items),
assertion_message,
)
def test_npc_neighbors(self):
def move_player_next_to_npc77():
pos_next_to_npc = [7, 8]
self.game.move_player(Constants.DOWN, pos_next_to_npc[0])
self.game.move_player(Constants.RIGHT, pos_next_to_npc[1])
self.assertEqual(pos_next_to_npc, self.game.player.pos)
actual_board_items = self.game.neighbors(1, self.npc77)
self.assertSetEqual(set(), set(actual_board_items))
move_player_next_to_npc77()
actual_board_items = self.game.neighbors(1, self.npc77)
self.assertSetEqual({self.game.player}, set(actual_board_items))
def dump_board_items(self):
h, w = self.board.size
for y in range(h):
for x in range(w):
boarditem = self.board.item(y, x)
assert isinstance(boarditem, BoardItem)
if isinstance(boarditem, BoardItemVoid):
continue
print(readable_board_item(boarditem))
