def main(argv):
if len(argv) != 2:
print "USAGE:", os.path.basename(argv[0]), "<game dat file>"
return
gamefile = argv[1]
exit_commands = ['quit', 'exit']
inventory_commands = ['inventory']
print "Opening file", gamefile
print
game = None
try:
with open(gamefile, 'r') as myfile:
game_blueprints = myfile.read().replace('\n', '')
game = Game(GameDecoder().decode(game_blueprints))
except IOError as e:
print "I/O error({0}): {1}".format(e.errno, e.strerror)
return
except Exception as e:
print "Could not parse game file."
print e
return
result = GameSyntaxChecker().check(game)
if result != "":
print "Error: ", result
return
print "Commands to use:",
for command in game.commands.keys() + exit_commands + inventory_commands:
print command,
print
print
looked = {}
while True:
if not game.current_room() in looked:
print game.look()
looked[game.current_room()] = True
else:
print "You are in a", game.current_room()
if game.won():
break
if len(game.stuffs()) > 0:
print "The following objects are in the room:",
for stuff in game.stuffs():
print stuff,
print "."
if len(game.directions()) > 0:
print "You can go to the following directions:",
for dirdesc in game.directions():
print dirdesc[0],
print "."
input_fields = []
while len(input_fields) <= 0:
input_fields = raw_input('>').split()
# better than split('')
if len(input_fields) > 3:
print "You cannot do that."
input_fields += [
'', ''
] # to set a default value for not given params in an easy way
if input_fields[1] == '' and input_fields[2] == '':
if input_fields[0] in exit_commands:
break
if input_fields[0] in inventory_commands:
if len(game.inventory()) > 0:
print 'You have the following items:',
for item in game.inventory():
print item,
print
else:
print 'You have no items.'
continue
try:
game.do_it(input_fields[0], input_fields[1], input_fields[2])
except Exception:
print "You cannot do that."
class GameUnitTests(unittest.TestCase):
# TODO: (IDEA) descriptions and images, the entire view should be a completely separated layer,
# which just portrays the game objects according to their attributes
# TODO: Write serializer
# TODO: Write view layer - first step is an object that returns an empty hash of texts indexed by game names
def setUp( self ):
# Test game1, just to start with something
self.game1_text_blueprints = """
[
[{"obj_content": {"attributes": [],
"childObjects": [{"obj_content": {"attributes": ["immobile"], "childObjects": [], "name": "table"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": [], "childObjects": [], "name": "candle"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": [], "childObjects": [], "name": "match"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": [], "childObjects": [], "name": "bird"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": [], "childObjects": [], "name": "stone"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": ["immobile", "invisible"], "childObjects": [], "name": "picture"}, "obj_name": "GameObject"}],
"name": "dark_room"},
"obj_name": "GameObject"},
{"obj_content": {"attributes": [],
"childObjects": [{"obj_content": {"attributes": ["immobile"],
"childObjects": [{"obj_content": {"attributes": [], "childObjects": [], "name": "knife"}, "obj_name": "GameObject"}],
"name": "cabinet"},
"obj_name": "GameObject"}],
"name": "bathroom"},
"obj_name": "GameObject"},
{"obj_content": {"attributes": [],
"childObjects": [],
"name": "secret_room"},
"obj_name": "GameObject"}],
[{"obj_content": {"attributes": [],
"childObjects": [],
"name": "burning_candle"},
"obj_name": "GameObject"},
{"obj_content": {"attributes": [],
"childObjects": [],
"name": "injured_bird"},
"obj_name": "GameObject"}],
[{"obj_content": {"room_name2": "bathroom", "room_name1": "dark_room", "direction2": "S", "attributes": [], "direction1": "N", "identifier": 11},
"obj_name": "GamePassage"},
{"obj_content": {"room_name2": "secret_room", "room_name1": "dark_room", "direction2": "E", "attributes": ["invisible"], "direction1": "W", "identifier": 12},
"obj_name": "GamePassage"}],
[{"obj_content": {"subjectname": "candle", "toolname": "match", "resultname": "burning_candle"},
"obj_name": "GameObjectUseAction"},
{"obj_content": {"subjectname": "bird", "toolname": "stone", "resultname": "injured_bird"},
"obj_name": "GameObjectUseAction"},
{"obj_content": {"subjectname": "picture", "toolname": "", "identifier": 12},
"obj_name": "GamePassageRevealAction"}],
[{"obj_content": {"subjectname": "picture", "toolname": "burning_candle"},
"obj_name": "GameObjectRevealAction"}],
"secret_room",
{"go#dark_room": "dark_room", "go#bathroom": "bathroom"}
]
"""
self.game1 = Game( [ [ GameObject( 'dark_room', [], [ GameObject( 'table', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'candle' ),
GameObject( 'match' ),
GameObject( 'bird' ),
GameObject( 'stone' ),
GameObject( 'picture', [GameObjectAttribute.IMMOBILE, GameObjectAttribute.INVISIBLE] ) ] ),
GameObject( 'bathroom', [], [ GameObject( 'cabinet', [GameObjectAttribute.IMMOBILE], [ GameObject( 'knife' ) ] ) ] ),
GameObject( 'secret_room' ) ],
[ GameObject( 'burning_candle' ), GameObject( 'injured_bird' ) ],
[ GamePassage( 11, 'dark_room', 'bathroom' , 'N', 'S' ),
GamePassage( 12, 'dark_room', 'secret_room', 'W', 'E', [GameObjectAttribute.INVISIBLE] ) ],
[ GameObjectUseAction( 'candle', 'match', 'burning_candle' ),
GameObjectUseAction( 'bird', 'stone', 'injured_bird' ),
GamePassageRevealAction( 'picture', '', 12 ) ],
[ GameObjectRevealAction( 'picture', 'burning_candle' ) ],
'secret_room',
{ 'go#dark_room' : 'dark_room', 'go#bathroom' : 'bathroom' } ] );
assert ( self.game1.look() == 'dark_room' )
assert ( self.game1.has( 'burning_candle' ) is None )
assert ( self.game1.has( 'candle' ) is None )
assert ( self.game1.has( 'match' ) is None )
assert ( 'candle' in self.game1.stuffs() )
assert ( 'match' in self.game1.stuffs() )
assert ( 'table' in self.game1.stuffs() )
assert ( not 'picture' in self.game1.stuffs() )
assert ( self.game1.directions() == [['N', 'bathroom']] )
assert ( self.game1.won() == 0 )
def test_syntax_checker_wrong_game_1(self):
# there is no room
game_internal = Game( [ [], [], [], [], [], '', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'must have at least one room' )
def test_syntax_checker_wrong_game_2(self):
# starting in the ending room
game_internal = Game( [ [ GameObject( 'room1', [], []) ], [], [], [], [], 'room1', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'cannot start in the ending room' )
def test_syntax_checker_wrong_game_3(self):
# starting in the ending room
game_internal = Game( [ [ GameObject( 'room1', [], []) ], [], [], [], [], 'final_room', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'final room does not exist' )
def test_syntax_checker_wrong_game_4(self):
game_internal = Game( [ [ GameObject( 'starting_room' ), GameObject( 'final_room' ) ], [], [], [], [], 'final_room', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'final room is not reachable' )
def test_syntax_checker_wrong_game_5(self):
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ),
GameObject( 'roomC' ), GameObject( 'roomD' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomC', 'roomD', 'N', 'S' ) ],
[], [], 'roomD', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'final room is not reachable' )
def test_syntax_checker_wrong_game_6(self):
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ),
GameObject( 'roomC' ), GameObject( 'roomD' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomB', 'roomC', 'N', 'S' ) ],
[], [], 'roomD', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'final room is not reachable' )
def test_syntax_checker_wrong_game_7(self):
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ),
GameObject( 'roomC' ), GameObject( 'roomD' ),
GameObject( 'roomE' ), GameObject( 'roomF' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomA', 'roomE', 'E', 'W' ),
GamePassage(13, 'roomE', 'roomB', 'N', 'E' ),
GamePassage(14, 'roomD', 'roomE', 'N', 'S' ),
GamePassage(15, 'roomC', 'roomF', 'E', 'W' ) ],
[], [], 'roomF', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'final room is not reachable' )
def test_syntax_checker_wrong_game_8(self):
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomA', 'roomB', 'W', 'S' ) ], [], [], 'roomB', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'multiple passages between the rooms roomA, roomB' )
def test_syntax_checker_wrong_game_9(self):
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomB', 'roomA', 'W', 'S' ) ], [], [], 'roomB', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'multiple passages between the rooms roomA, roomB' )
def test_syntax_checker_wrong_game_10(self):
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ), GameObject( 'roomC' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(11, 'roomB', 'roomC', 'W', 'S' ) ], [], [], 'roomC', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'passage identifiers are not unique, 11' )
def test_syntax_checker_wrong_game_11(self):
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ),
GameObject( 'roomC' ), GameObject( 'roomD' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomC', 'roomD', 'N', 'S' ) ],
[], [], 'roomB', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'not all rooms are accessible, roomC' )
def test_syntax_checker_wrong_game_12(self):
game_internal = Game( [ [ GameObject( 'roomA', [], [ GameObject( 'button', [GameObjectAttribute.IMMOBILE], [] ) ] ),
GameObject( 'roomB' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'button', '', 13 ) ],
[],
'roomB',
{} ] )
assert ( GameSyntaxChecker().check( game_internal ) == 'invalid passage identifiers in an action, 13' )
def test_syntax_checker_wrong_game_13(self):
game_internal = Game( [ [ GameObject( 'roomA',[], [ GameObject( 'button1', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'button2', [GameObjectAttribute.IMMOBILE], [] ) ] ),
GameObject( 'roomB' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'button', '', 11 ) ],
[],
'roomB',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found invalid object in an action, button' )
def test_syntax_checker_wrong_game_14(self):
game_internal = Game( [ [ GameObject( 'roomA', [], [ GameObject( 'button1', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'button1', [GameObjectAttribute.IMMOBILE], [] ) ] ),
GameObject( 'roomB' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'button1', '', 11 ) ],
[],
'roomB',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found two objects with the same name, button1' )
def test_syntax_checker_wrong_game_15(self):
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomC' ),
GameObject( 'roomB' ), GameObject( 'roomC' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomB', 'roomC', 'N', 'S' ) ],
[], [], 'roomC', {} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found two objects with the same name, roomC' )
def test_syntax_checker_wrong_game16(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( '', '', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found an action without actors' )
def test_syntax_checker_wrong_game17(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', 'door', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found invalid action with the same actor twice, door' )
def test_syntax_checker_wrong_game_18(self):
game_internal = Game( [ [ GameObject( 'roomA', [], [ GameObject( 'button1', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'button2', [GameObjectAttribute.IMMOBILE], [] ) ] ),
GameObject( 'roomB' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'button1', '', 11 ),
GamePassageRevealAction( 'button1', '', 11 ) ],
[],
'roomB',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found multiple actions for the same actor, button1' )
def test_syntax_checker_wrong_game_19(self):
game_internal = Game( [ [ GameObject( 'roomA', [], [ GameObject( 'button1', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'button2', [GameObjectAttribute.IMMOBILE], [] ) ] ),
GameObject( 'roomB' ) ],
[ GameObject( 'broken button' ) ],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'button1', '', 11 ),
GameObjectUseAction( '', 'button1', 'broken button' ) ],
[],
'roomB',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found multiple actions for the same actor, button1' )
def test_syntax_checker_wrong_game_20(self):
game_internal = Game( [ [ GameObject( 'roomA', [], [ GameObject( 'handle1', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'handle2', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'crowbar' ) ] ),
GameObject( 'roomB' ) ],
[ GameObject( 'broken handle' ) ],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'handle1', 'crowbar', 11 ),
GameObjectUseAction( 'handle2', 'crowbar', 'broken handle' ) ],
[],
'roomB',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found multiple actions for the same actor, crowbar' )
def test_syntax_checker_wrong_game_21(self):
game_internal = Game( [ [ GameObject( 'roomA', [], [ GameObject( 'handle1', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'handle2', [GameObjectAttribute.IMMOBILE], [] ),
GameObject( 'crowbar' ) ] ),
GameObject( 'roomB' ) ],
[ GameObject( 'handle1' ) ],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'handle1', 'crowbar', 11 ),
GameObjectUseAction( 'handle2', 'crowbar', 'handle1' ) ],
[],
'roomB',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'found two objects with the same name, handle1' )
def test_syntax_checker_wrong_game22(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'box', [GameObjectAttribute.IMMOBILE],
[GameObject( 'key', [GameObjectAttribute.IMMOBILE] ) ] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'not top level stuffs cannot have attributes, key' )
def test_syntax_checker_wrong_game23(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'keypart1' ),
GameObject( 'box', [GameObjectAttribute.IMMOBILE], [GameObject( 'keypart2' ) ] ) ] ),
GameObject( 'ending_room' ) ],
[ GameObject( 'key', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ),
GameObjectUseAction( 'keypart1', 'keypart2', 'key' ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'not top level stuffs cannot have attributes, key' )
def test_syntax_checker_wrong_game24(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'key', [GameObjectAttribute.INVISIBLE] ) ] ),
GameObject( 'middle_room' , [], [ GameObject( 'burning_candle' ),
GameObject( 'door', [GameObjectAttribute.IMMOBILE] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'middle_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ),
GamePassage( 12, 'starting_room', 'middle_room' , 'N', 'S' ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ) ],
[ GameObjectRevealAction( 'burning_candle', 'key') ],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'subjects of revealing actions must be invisible initially, burning_candle' )
def test_syntax_checker_wrong_game25(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'key' , [GameObjectAttribute.IMMOBILE] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == "action actor key must be mobile" )
def test_syntax_checker_wrong_game26(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE, GameObjectAttribute.INVISIBLE] ),
GameObject( 'key' ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'there must be exactly one action for each invisible object which reveals it, door' )
def test_syntax_checker_wrong_game27(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'key' , [] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'key', 'door', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == "action actor door must be mobile" )
def test_syntax_checker_wrong_game28(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'key' , [] ) ] ),
GameObject( 'ending_room' ) ],
[ GameObject( 'broken_key' ) ],
[ GamePassage( 11, 'starting_room', 'strange_room' , 'W', 'E', [] ),
GamePassage( 12, 'strange_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GameObjectUseAction( 'door', 'key', 'broken_key' ) ],
[ GamePassageRevealAction( 'broken_key', '', 12 )],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == "found not existing room in a passage: strange_room" )
def test_syntax_checker_wrong_game29(self):
game_internal = Game( [ [ GameObject( 'starting_room' ), GameObject( 'final/room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'final/room', 'N', 'S' ) ], [], [], 'final/room', {} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == 'game object names can contain only lower case alphabets and _, final/room' )
def test_syntax_checker_good_game1(self):
# minimal valid game
game_internal = Game( [ [ GameObject( 'starting_room' ), GameObject( 'final_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'final_room', 'N', 'S' ) ], [], [], 'final_room', {} ] )
assert ( GameSyntaxChecker().check( game_internal ) == '' )
assert ( GameSolver().solve( game_internal ) == [ [ 'go', 'N' ] ] )
def test_syntax_checker_good_game_2(self):
# testing whether final room is accessible
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ),
GameObject( 'roomC' ), GameObject( 'roomD' ),
GameObject( 'roomE' ), GameObject( 'roomF' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomA', 'roomE', 'E', 'W' ),
GamePassage(13, 'roomD', 'roomC', 'E', 'W' ),
GamePassage(14, 'roomE', 'roomB', 'N', 'E' ),
GamePassage(15, 'roomD', 'roomE', 'N', 'S' ),
GamePassage(16, 'roomC', 'roomF', 'E', 'W' ) ],
[],
[],
'roomF',
{} ] )
assert ( GameSyntaxChecker().check( game_internal ) == '' )
assert ( GameSolver().solve( game_internal ) == [ [ 'go', 'N' ], [ 'go', 'E' ], [ 'go', 'S' ], [ 'go', 'E' ], [ 'go', 'E' ] ] )
def test_syntax_checker_good_game3(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', '', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == '' )
assert ( GameSolver().solve( game_internal ) == [['use', '', 'door'], ['go', 'N']] )
def test_syntax_checker_good_game4(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'key' ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == '' )
assert ( GameSolver().solve( game_internal ) == [['take', 'key'], ['use', 'door', 'key'], ['go', 'N']] )
def test_syntax_checker_good_game5(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'box', [GameObjectAttribute.IMMOBILE], [GameObject( 'key' ) ] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == '' )
solution = GameSolver().solve( game_internal )
assert ( solution == [['open', 'box'], ['take', 'key'], ['use', 'door', 'key'], ['go', 'N']] )
def test_syntax_checker_good_game6(self):
game_internal = Game( [ [ GameObject( 'starting_room' ),
GameObject( 'middle_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'box', [GameObjectAttribute.IMMOBILE], [GameObject( 'key' ) ] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'middle_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ),
GamePassage( 12, 'starting_room', 'middle_room' , 'N', 'S' ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == '' )
solution = GameSolver().solve( game_internal )
assert ( solution == [['go', 'N'],['open', 'box'], ['take', 'key'], ['use', 'door', 'key'], ['go', 'N']] )
def test_syntax_checker_good_game7(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'key', [GameObjectAttribute.INVISIBLE] ) ] ),
GameObject( 'middle_room' , [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'box', [GameObjectAttribute.IMMOBILE], [GameObject( 'burning_candle' ) ] ) ] ),
GameObject( 'ending_room' ) ],
[],
[ GamePassage( 11, 'middle_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ),
GamePassage( 12, 'starting_room', 'middle_room' , 'N', 'S' ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ) ],
[ GameObjectRevealAction( 'key', 'burning_candle') ],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == '' )
solution = GameSolver().solve( game_internal )
assert ( solution == [['go', 'N'], ['open', 'box'], ['take', 'burning_candle'], ['go', 'S'], ['take', 'key'], ['go', 'N'], ['use', 'door', 'key'], ['go', 'N']] )
def test_syntax_checker_good_game8(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'keypart1' ),
GameObject( 'box', [GameObjectAttribute.IMMOBILE], [GameObject( 'keypart2' ) ] ) ] ),
GameObject( 'ending_room' ) ],
[ GameObject( 'key' ) ],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GamePassageRevealAction( 'door', 'key', 11 ),
GameObjectUseAction( 'keypart1', 'keypart2', 'key' ) ],
[],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == '' )
solution = GameSolver().solve( game_internal )
assert ( solution == [['take', 'keypart1'], ['open', 'box'], ['take', 'keypart2'], ['use', 'keypart1', 'keypart2'], ['use', 'door', 'key'], ['go', 'N']] )
# Here use action + passage reval view = use passage reveal, so it is just
# pure complication. game10 may make the possibility of the separaton more meaningful.
def test_syntax_checker_good_game9(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'key' , [] ) ] ),
GameObject( 'ending_room' ) ],
[ GameObject( 'broken_key' ) ],
[ GamePassage( 11, 'starting_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GameObjectUseAction( 'door', 'key', 'broken_key' ) ],
[ GamePassageRevealAction( 'broken_key', '', 11 )],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == "" )
assert ( GameSolver().solve( game_internal ) == [['take', 'key'], ['use', 'door', 'key'], ['go', 'N']] )
def test_syntax_checker_good_game10(self):
game_internal = Game( [ [ GameObject( 'starting_room', [], [ GameObject( 'door', [GameObjectAttribute.IMMOBILE] ),
GameObject( 'key' , [] ) ] ),
GameObject( 'strange_room' ),
GameObject( 'ending_room' ) ],
[ GameObject( 'broken_key' ) ],
[ GamePassage( 11, 'starting_room', 'strange_room' , 'W', 'E', [] ),
GamePassage( 12, 'strange_room', 'ending_room' , 'N', 'S', [GameObjectAttribute.INVISIBLE] ) ],
[ GameObjectUseAction( 'door', 'key', 'broken_key' ) ],
[ GamePassageRevealAction( 'broken_key', '', 12 )],
'ending_room',
{} ] )
verdict = GameSyntaxChecker().check( game_internal )
assert ( verdict == "" )
assert ( GameSolver().solve( game_internal ) == [['take', 'key'], ['use', 'door', 'key'], ['go', 'W'], ['go', 'N']] )
def test_take_and_drop_existing_object(self):
subject = self.game1.do_it( 'take', 'candle' )
assert ( not subject is None )
assert ( not self.game1.has( 'candle' ) is None )
assert ( not 'candle' in self.game1.stuffs() )
subject = self.game1.do_it( 'drop', 'candle' )
assert ( not subject is None )
assert ( self.game1.has( 'candle' ) is None )
def test_trying_take_not_existing_object(self):
subject = self.game1.do_it( 'take', 'banana' )
assert ( subject is None )
assert ( self.game1.has( 'banana' ) is None )
def test_trying_take_immobile_object(self):
subject = self.game1.do_it( 'take', 'table' )
assert ( subject is None )
assert ( self.game1.has( 'table' ) is None )
def test_action_hit_the_bird_with_the_stone(self):
self.game1.do_it( 'take', 'stone' )
object1 = self.game1.do_it( 'use', 'stone', 'bird' )
assert ( not object1 is None )
assert ( not 'bird' in self.game1.stuffs() )
assert ( self.game1.has( 'stone' ) is None )
assert ( 'injured_bird' in self.game1.stuffs() )
object2 = self.game1.do_it( 'use', 'stone', 'bird' )
assert ( object2 is None )
def test_action_hit_the_bird_with_the_stone_but_both_are_in_inventory(self):
self.game1.do_it( 'take', 'stone' )
self.game1.do_it( 'take', 'bird' )
object1 = self.game1.do_it( 'use', 'stone', 'bird' )
assert ( not self.game1.has( 'injured_bird' ) is None )
def test_action_hit_the_bird_with_the_stone_but_use_params_are_reversed(self):
self.game1.do_it( 'take', 'stone' )
self.game1.do_it( 'use', 'bird', 'stone' )
assert ( 'injured_bird' in self.game1.stuffs() )
def test_room_goes_light_from_dark_if_we_burn_the_candle_without_taking_it_first(self):
self.game1.do_it( 'take', 'match' )
self.game1.do_it( 'use', 'candle', 'match' )
assert( not 'candle' in self.game1.stuffs() )
assert( 'burning_candle' in self.game1.stuffs() )
assert( 'picture' in self.game1.stuffs() )
def test_room_goes_light_from_dark_if_we_burn_the_candle_with_taking_it_first(self):
self.game1.do_it( 'take', 'candle' )
self.game1.do_it( 'take', 'match' )
self.game1.do_it( 'use', 'candle', 'match' )
assert ( not self.game1.has( 'burning_candle' ) is None )
assert( 'picture' in self.game1.stuffs() )
def test_moving_between_rooms(self):
self.game1.do_it( 'go', 'N')
assert( self.game1.look() == 'bathroom' )
assert ( self.game1.directions() == [['S', 'dark_room']] )
self.game1.do_it( 'go', 'S')
assert( self.game1.look() == 'dark_room' )
def test_opening_objects(self):
self.game1.do_it( 'go', 'N')
assert( not 'knife' in self.game1.stuffs() )
assert ( self.game1.do_it( 'open', 'cabinet' ) )
assert( 'knife' in self.game1.stuffs() )
def test_moving_between_rooms_and_carrying_object(self):
subject = self.game1.do_it( 'take', 'candle')
self.game1.do_it( 'go', 'N')
self.game1.do_it( 'drop', 'candle')
self.game1.do_it( 'go', 'S')
assert( self.game1.look() == 'dark_room' )
assert( not 'candle' in self.game1.stuffs() )
def test_recognizing_a_new_object_through_a_view_and_it_becomes_permanent(self):
self.game1.do_it( 'take', 'match' )
object1 = self.game1.do_it( 'use', 'candle', 'match' )
self.game1.do_it( 'take', 'burning_candle')
self.game1.do_it( 'go', 'N')
self.game1.do_it( 'drop', 'burning_candle')
self.game1.do_it( 'go', 'S')
assert( self.game1.look() == 'dark_room' )
assert( 'picture' in self.game1.stuffs() )
def test_finding_a_new_passage(self):
self.test_recognizing_a_new_object_through_a_view_and_it_becomes_permanent()
assert( 'picture' in self.game1.stuffs() )
self.game1.do_it( 'use','picture')
assert ( self.game1.directions() == [['N', 'bathroom'], ['W', 'secret_room']] )
def test_winning_the_game(self):
self.test_finding_a_new_passage()
self.game1.do_it( 'go', 'W')
assert ( self.game1.won() == 1 )
def test_solver_on_full_game(self):
verdict = GameSyntaxChecker().check( self.game1 )
assert ( verdict == '' )
solution = GameSolver().solve( self.game1 )
assert ( solution == [ ['take', 'candle'], ['take', 'match'], ['take', 'bird'], ['take', 'stone'], ['use', 'candle', 'match'],
['use', 'bird', 'stone'], ['use', '', 'picture'], ['go', 'W']] )
def test_json_serializer_deserializer(self):
game1_text_blueprints_reconstructed = json.dumps( self.game1.get_blueprints(), cls=GameEncoder );
array_game_description_reconstructed = GameDecoder().decode( game1_text_blueprints_reconstructed );
assert( self.game1.get_blueprints() == array_game_description_reconstructed )
def test_json_deserializer_serializer(self):
array_game_description = GameDecoder().decode( self.game1_text_blueprints );
text_game_description2 = json.dumps( array_game_description, cls=GameEncoder );
array_game_description2 = GameDecoder().decode( text_game_description2 );
assert( array_game_description == array_game_description2 )
def test_json_game_deserializer_serializer_1(self):
game_internal_text = '[[{"obj_content": {"attributes": [], "childObjects": [], "name": "roomA"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomB"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomC"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomD"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomE"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomF"}, "obj_name": "GameObject"}],\
[],\
[{"obj_content": {"room_name2": "roomB", "room_name1": "roomA", "direction2": "S", "attributes": [], "direction1": "N", "identifier": 11},\
"obj_name": "GamePassage"},\
{"obj_content": {"room_name2": "roomE", "room_name1": "roomA", "direction2": "W", "attributes": [], "direction1": "E", "identifier": 12},\
"obj_name": "GamePassage"},\
{"obj_content": {"room_name2": "roomB", "room_name1": "roomE", "direction2": "E", "attributes": [], "direction1": "N", "identifier": 13},\
"obj_name": "GamePassage"},\
{"obj_content": {"room_name2": "roomE", "room_name1": "roomD", "direction2": "S", "attributes": [], "direction1": "N", "identifier": 14},\
"obj_name": "GamePassage"},\
{"obj_content": {"room_name2": "roomF", "room_name1": "roomC", "direction2": "W", "attributes": [], "direction1": "E", "identifier": 15},\
"obj_name": "GamePassage"}], [], [], "roomF", {}]'
game_from_text = Game( GameDecoder().decode( game_internal_text ) )
game_internal = Game( [ [ GameObject( 'roomA' ), GameObject( 'roomB' ),
GameObject( 'roomC' ), GameObject( 'roomD' ),
GameObject( 'roomE' ), GameObject( 'roomF' ) ],
[],
[ GamePassage(11, 'roomA', 'roomB', 'N', 'S' ),
GamePassage(12, 'roomA', 'roomE', 'E', 'W' ),
GamePassage(13, 'roomE', 'roomB', 'N', 'E' ),
GamePassage(14, 'roomD', 'roomE', 'N', 'S' ),
GamePassage(15, 'roomC', 'roomF', 'E', 'W' ) ],
[], [], 'roomF', {} ] )
assert( game_internal == game_from_text )
def test_json_game_deserializer_serializer_2(self):
game_from_text = Game( GameDecoder().decode( self.game1_text_blueprints ) )
assert( self.game1 == game_from_text )
class GameUnitTests(unittest.TestCase):
# TODO: (IDEA) descriptions and images, the entire view should be a completely separated layer,
# which just portrays the game objects according to their attributes
# TODO: Write serializer
# TODO: Write view layer - first step is an object that returns an empty hash of texts indexed by game names
def setUp(self):
# Test game1, just to start with something
self.game1_text_blueprints = """
[
[{"obj_content": {"attributes": [],
"childObjects": [{"obj_content": {"attributes": ["immobile"], "childObjects": [], "name": "table"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": [], "childObjects": [], "name": "candle"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": [], "childObjects": [], "name": "match"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": [], "childObjects": [], "name": "bird"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": [], "childObjects": [], "name": "stone"}, "obj_name": "GameObject"},
{"obj_content": {"attributes": ["immobile", "invisible"], "childObjects": [], "name": "picture"}, "obj_name": "GameObject"}],
"name": "dark_room"},
"obj_name": "GameObject"},
{"obj_content": {"attributes": [],
"childObjects": [{"obj_content": {"attributes": ["immobile"],
"childObjects": [{"obj_content": {"attributes": [], "childObjects": [], "name": "knife"}, "obj_name": "GameObject"}],
"name": "cabinet"},
"obj_name": "GameObject"}],
"name": "bathroom"},
"obj_name": "GameObject"},
{"obj_content": {"attributes": [],
"childObjects": [],
"name": "secret_room"},
"obj_name": "GameObject"}],
[{"obj_content": {"attributes": [],
"childObjects": [],
"name": "burning_candle"},
"obj_name": "GameObject"},
{"obj_content": {"attributes": [],
"childObjects": [],
"name": "injured_bird"},
"obj_name": "GameObject"}],
[{"obj_content": {"room_name2": "bathroom", "room_name1": "dark_room", "direction2": "S", "attributes": [], "direction1": "N", "identifier": 11},
"obj_name": "GamePassage"},
{"obj_content": {"room_name2": "secret_room", "room_name1": "dark_room", "direction2": "E", "attributes": ["invisible"], "direction1": "W", "identifier": 12},
"obj_name": "GamePassage"}],
[{"obj_content": {"subjectname": "candle", "toolname": "match", "resultname": "burning_candle"},
"obj_name": "GameObjectUseAction"},
{"obj_content": {"subjectname": "bird", "toolname": "stone", "resultname": "injured_bird"},
"obj_name": "GameObjectUseAction"},
{"obj_content": {"subjectname": "picture", "toolname": "", "identifier": 12},
"obj_name": "GamePassageRevealAction"}],
[{"obj_content": {"subjectname": "picture", "toolname": "burning_candle"},
"obj_name": "GameObjectRevealAction"}],
"secret_room",
{"go#dark_room": "dark_room", "go#bathroom": "bathroom"}
]
"""
self.game1 = Game([[
GameObject('dark_room', [], [
GameObject('table', [GameObjectAttribute.IMMOBILE], []),
GameObject('candle'),
GameObject('match'),
GameObject('bird'),
GameObject('stone'),
GameObject('picture', [
GameObjectAttribute.IMMOBILE, GameObjectAttribute.INVISIBLE
])
]),
GameObject('bathroom', [], [
GameObject('cabinet', [GameObjectAttribute.IMMOBILE],
[GameObject('knife')])
]),
GameObject('secret_room')
], [GameObject('burning_candle'),
GameObject('injured_bird')],
[
GamePassage(11, 'dark_room', 'bathroom', 'N',
'S'),
GamePassage(12, 'dark_room', 'secret_room', 'W',
'E',
[GameObjectAttribute.INVISIBLE])
],
[
GameObjectUseAction('candle', 'match',
'burning_candle'),
GameObjectUseAction('bird', 'stone',
'injured_bird'),
GamePassageRevealAction('picture', '', 12)
],
[
GameObjectRevealAction('picture',
'burning_candle')
], 'secret_room', {
'go#dark_room': 'dark_room',
'go#bathroom': 'bathroom'
}])
assert (self.game1.look() == 'dark_room')
assert (self.game1.has('burning_candle') is None)
assert (self.game1.has('candle') is None)
assert (self.game1.has('match') is None)
assert ('candle' in self.game1.stuffs())
assert ('match' in self.game1.stuffs())
assert ('table' in self.game1.stuffs())
assert (not 'picture' in self.game1.stuffs())
assert (self.game1.directions() == [['N', 'bathroom']])
assert (self.game1.won() == 0)
def test_syntax_checker_wrong_game_1(self):
# there is no room
game_internal = Game([[], [], [], [], [], '', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'must have at least one room')
def test_syntax_checker_wrong_game_2(self):
# starting in the ending room
game_internal = Game([[GameObject('room1', [], [])], [], [], [], [],
'room1', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'cannot start in the ending room')
def test_syntax_checker_wrong_game_3(self):
# starting in the ending room
game_internal = Game([[GameObject('room1', [], [])], [], [], [], [],
'final_room', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'final room does not exist')
def test_syntax_checker_wrong_game_4(self):
game_internal = Game(
[[GameObject('starting_room'),
GameObject('final_room')], [], [], [], [], 'final_room', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'final room is not reachable')
def test_syntax_checker_wrong_game_5(self):
game_internal = Game([[
GameObject('roomA'),
GameObject('roomB'),
GameObject('roomC'),
GameObject('roomD')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomC', 'roomD', 'N', 'S')
], [], [], 'roomD', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'final room is not reachable')
def test_syntax_checker_wrong_game_6(self):
game_internal = Game([[
GameObject('roomA'),
GameObject('roomB'),
GameObject('roomC'),
GameObject('roomD')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomB', 'roomC', 'N', 'S')
], [], [], 'roomD', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'final room is not reachable')
def test_syntax_checker_wrong_game_7(self):
game_internal = Game([[
GameObject('roomA'),
GameObject('roomB'),
GameObject('roomC'),
GameObject('roomD'),
GameObject('roomE'),
GameObject('roomF')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomA', 'roomE', 'E', 'W'),
GamePassage(13, 'roomE', 'roomB', 'N', 'E'),
GamePassage(14, 'roomD', 'roomE', 'N', 'S'),
GamePassage(15, 'roomC', 'roomF', 'E', 'W')
], [], [], 'roomF', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'final room is not reachable')
def test_syntax_checker_wrong_game_8(self):
game_internal = Game([[GameObject('roomA'),
GameObject('roomB')], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomA', 'roomB', 'W', 'S')
], [], [], 'roomB', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'multiple passages between the rooms roomA, roomB')
def test_syntax_checker_wrong_game_9(self):
game_internal = Game([[GameObject('roomA'),
GameObject('roomB')], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomB', 'roomA', 'W', 'S')
], [], [], 'roomB', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'multiple passages between the rooms roomA, roomB')
def test_syntax_checker_wrong_game_10(self):
game_internal = Game(
[[GameObject('roomA'),
GameObject('roomB'),
GameObject('roomC')], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(11, 'roomB', 'roomC', 'W', 'S')
], [], [], 'roomC', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'passage identifiers are not unique, 11')
def test_syntax_checker_wrong_game_11(self):
game_internal = Game([[
GameObject('roomA'),
GameObject('roomB'),
GameObject('roomC'),
GameObject('roomD')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomC', 'roomD', 'N', 'S')
], [], [], 'roomB', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'not all rooms are accessible, roomC')
def test_syntax_checker_wrong_game_12(self):
game_internal = Game([[
GameObject(
'roomA', [],
[GameObject('button', [GameObjectAttribute.IMMOBILE], [])]),
GameObject('roomB')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('button', '', 13)],
[], 'roomB', {}])
assert (GameSyntaxChecker().check(game_internal) ==
'invalid passage identifiers in an action, 13')
def test_syntax_checker_wrong_game_13(self):
game_internal = Game([[
GameObject('roomA', [], [
GameObject('button1', [GameObjectAttribute.IMMOBILE], []),
GameObject('button2', [GameObjectAttribute.IMMOBILE], [])
]),
GameObject('roomB')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('button', '', 11)],
[], 'roomB', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == 'found invalid object in an action, button')
def test_syntax_checker_wrong_game_14(self):
game_internal = Game([[
GameObject('roomA', [], [
GameObject('button1', [GameObjectAttribute.IMMOBILE], []),
GameObject('button1', [GameObjectAttribute.IMMOBILE], [])
]),
GameObject('roomB')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('button1', '', 11)],
[], 'roomB', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == 'found two objects with the same name, button1')
def test_syntax_checker_wrong_game_15(self):
game_internal = Game([[
GameObject('roomA'),
GameObject('roomC'),
GameObject('roomB'),
GameObject('roomC')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomB', 'roomC', 'N', 'S')
], [], [], 'roomC', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == 'found two objects with the same name, roomC')
def test_syntax_checker_wrong_game16(self):
game_internal = Game([[
GameObject('starting_room', [],
[GameObject('door', [GameObjectAttribute.IMMOBILE])]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('', '', 11)], [],
'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == 'found an action without actors')
def test_syntax_checker_wrong_game17(self):
game_internal = Game([[
GameObject('starting_room', [],
[GameObject('door', [GameObjectAttribute.IMMOBILE])]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('door', 'door', 11)],
[], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (
verdict == 'found invalid action with the same actor twice, door')
def test_syntax_checker_wrong_game_18(self):
game_internal = Game([[
GameObject('roomA', [], [
GameObject('button1', [GameObjectAttribute.IMMOBILE], []),
GameObject('button2', [GameObjectAttribute.IMMOBILE], [])
]),
GameObject('roomB')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
],
[
GamePassageRevealAction('button1', '', 11),
GamePassageRevealAction('button1', '', 11)
], [], 'roomB', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (
verdict == 'found multiple actions for the same actor, button1')
def test_syntax_checker_wrong_game_19(self):
game_internal = Game([[
GameObject('roomA', [], [
GameObject('button1', [GameObjectAttribute.IMMOBILE], []),
GameObject('button2', [GameObjectAttribute.IMMOBILE], [])
]),
GameObject('roomB')
], [GameObject('broken button')],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
],
[
GamePassageRevealAction('button1', '', 11),
GameObjectUseAction('', 'button1',
'broken button')
], [], 'roomB', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (
verdict == 'found multiple actions for the same actor, button1')
def test_syntax_checker_wrong_game_20(self):
game_internal = Game([[
GameObject('roomA', [], [
GameObject('handle1', [GameObjectAttribute.IMMOBILE], []),
GameObject('handle2', [GameObjectAttribute.IMMOBILE], []),
GameObject('crowbar')
]),
GameObject('roomB')
], [GameObject('broken handle')],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
],
[
GamePassageRevealAction(
'handle1', 'crowbar', 11),
GameObjectUseAction('handle2', 'crowbar',
'broken handle')
], [], 'roomB', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (
verdict == 'found multiple actions for the same actor, crowbar')
def test_syntax_checker_wrong_game_21(self):
game_internal = Game([[
GameObject('roomA', [], [
GameObject('handle1', [GameObjectAttribute.IMMOBILE], []),
GameObject('handle2', [GameObjectAttribute.IMMOBILE], []),
GameObject('crowbar')
]),
GameObject('roomB')
], [GameObject('handle1')],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
],
[
GamePassageRevealAction(
'handle1', 'crowbar', 11),
GameObjectUseAction('handle2', 'crowbar',
'handle1')
], [], 'roomB', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == 'found two objects with the same name, handle1')
def test_syntax_checker_wrong_game22(self):
game_internal = Game([[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('box', [GameObjectAttribute.IMMOBILE],
[GameObject('key', [GameObjectAttribute.IMMOBILE])])
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('door', 'key', 11)],
[], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == 'not top level stuffs cannot have attributes, key')
def test_syntax_checker_wrong_game23(self):
game_internal = Game([[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('keypart1'),
GameObject('box', [GameObjectAttribute.IMMOBILE],
[GameObject('keypart2')])
]),
GameObject('ending_room')
], [GameObject('key', [GameObjectAttribute.INVISIBLE])],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
],
[
GamePassageRevealAction('door', 'key', 11),
GameObjectUseAction('keypart1', 'keypart2',
'key')
], [], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == 'not top level stuffs cannot have attributes, key')
def test_syntax_checker_wrong_game24(self):
game_internal = Game(
[[
GameObject(
'starting_room', [],
[GameObject('key', [GameObjectAttribute.INVISIBLE])]),
GameObject('middle_room', [], [
GameObject('burning_candle'),
GameObject('door', [GameObjectAttribute.IMMOBILE])
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'middle_room', 'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE]),
GamePassage(12, 'starting_room', 'middle_room', 'N', 'S')
], [GamePassageRevealAction('door', 'key', 11)],
[GameObjectRevealAction('burning_candle', 'key')], 'ending_room',
{}])
verdict = GameSyntaxChecker().check(game_internal)
assert (
verdict ==
'subjects of revealing actions must be invisible initially, burning_candle'
)
def test_syntax_checker_wrong_game25(self):
game_internal = Game([[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('key', [GameObjectAttribute.IMMOBILE])
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('door', 'key', 11)],
[], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == "action actor key must be mobile")
def test_syntax_checker_wrong_game26(self):
game_internal = Game([[
GameObject('starting_room', [], [
GameObject('door', [
GameObjectAttribute.IMMOBILE, GameObjectAttribute.INVISIBLE
]),
GameObject('key')
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('door', 'key', 11)],
[], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (
verdict ==
'there must be exactly one action for each invisible object which reveals it, door'
)
def test_syntax_checker_wrong_game27(self):
game_internal = Game([[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('key', [])
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('key', 'door', 11)],
[], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == "action actor door must be mobile")
def test_syntax_checker_wrong_game28(self):
game_internal = Game(
[[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('key', [])
]),
GameObject('ending_room')
], [GameObject('broken_key')],
[
GamePassage(11, 'starting_room', 'strange_room', 'W', 'E',
[]),
GamePassage(12, 'strange_room', 'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GameObjectUseAction('door', 'key', 'broken_key')],
[GamePassageRevealAction('broken_key', '', 12)], 'ending_room',
{}])
verdict = GameSyntaxChecker().check(game_internal)
assert (
verdict == "found not existing room in a passage: strange_room")
def test_syntax_checker_wrong_game29(self):
game_internal = Game(
[[GameObject('starting_room'),
GameObject('final/room')], [],
[GamePassage(11, 'starting_room', 'final/room', 'N', 'S')], [],
[], 'final/room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (
verdict ==
'game object names can contain only lower case alphabets and _, final/room'
)
def test_syntax_checker_good_game1(self):
# minimal valid game
game_internal = Game(
[[GameObject('starting_room'),
GameObject('final_room')], [],
[GamePassage(11, 'starting_room', 'final_room', 'N', 'S')], [],
[], 'final_room', {}])
assert (GameSyntaxChecker().check(game_internal) == '')
assert (GameSolver().solve(game_internal) == [['go', 'N']])
def test_syntax_checker_good_game_2(self):
# testing whether final room is accessible
game_internal = Game([[
GameObject('roomA'),
GameObject('roomB'),
GameObject('roomC'),
GameObject('roomD'),
GameObject('roomE'),
GameObject('roomF')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomA', 'roomE', 'E', 'W'),
GamePassage(13, 'roomD', 'roomC', 'E', 'W'),
GamePassage(14, 'roomE', 'roomB', 'N', 'E'),
GamePassage(15, 'roomD', 'roomE', 'N', 'S'),
GamePassage(16, 'roomC', 'roomF', 'E', 'W')
], [], [], 'roomF', {}])
assert (GameSyntaxChecker().check(game_internal) == '')
assert (GameSolver().solve(game_internal) == [['go', 'N'], ['go', 'E'],
['go', 'S'], ['go', 'E'],
['go', 'E']])
def test_syntax_checker_good_game3(self):
game_internal = Game([[
GameObject('starting_room', [],
[GameObject('door', [GameObjectAttribute.IMMOBILE])]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('door', '', 11)], [],
'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == '')
assert (GameSolver().solve(game_internal) == [['use', '', 'door'],
['go', 'N']])
def test_syntax_checker_good_game4(self):
game_internal = Game([[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('key')
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('door', 'key', 11)],
[], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == '')
assert (GameSolver().solve(game_internal) == [['take', 'key'],
['use', 'door', 'key'],
['go', 'N']])
def test_syntax_checker_good_game5(self):
game_internal = Game([[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('box', [GameObjectAttribute.IMMOBILE],
[GameObject('key')])
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GamePassageRevealAction('door', 'key', 11)],
[], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == '')
solution = GameSolver().solve(game_internal)
assert (solution == [['open', 'box'], ['take', 'key'],
['use', 'door', 'key'], ['go', 'N']])
def test_syntax_checker_good_game6(self):
game_internal = Game([[
GameObject('starting_room'),
GameObject('middle_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('box', [GameObjectAttribute.IMMOBILE],
[GameObject('key')])
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'middle_room', 'ending_room',
'N', 'S',
[GameObjectAttribute.INVISIBLE]),
GamePassage(12, 'starting_room',
'middle_room', 'N', 'S')
], [GamePassageRevealAction('door', 'key', 11)],
[], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == '')
solution = GameSolver().solve(game_internal)
assert (solution == [['go', 'N'], ['open', 'box'], ['take', 'key'],
['use', 'door', 'key'], ['go', 'N']])
def test_syntax_checker_good_game7(self):
game_internal = Game(
[[
GameObject(
'starting_room', [],
[GameObject('key', [GameObjectAttribute.INVISIBLE])]),
GameObject('middle_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('box', [GameObjectAttribute.IMMOBILE],
[GameObject('burning_candle')])
]),
GameObject('ending_room')
], [],
[
GamePassage(11, 'middle_room', 'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE]),
GamePassage(12, 'starting_room', 'middle_room', 'N', 'S')
], [GamePassageRevealAction('door', 'key', 11)],
[GameObjectRevealAction('key', 'burning_candle')], 'ending_room',
{}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == '')
solution = GameSolver().solve(game_internal)
assert (solution == [['go', 'N'], ['open', 'box'],
['take', 'burning_candle'], ['go', 'S'],
['take', 'key'], ['go', 'N'],
['use', 'door', 'key'], ['go', 'N']])
def test_syntax_checker_good_game8(self):
game_internal = Game([[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('keypart1'),
GameObject('box', [GameObjectAttribute.IMMOBILE],
[GameObject('keypart2')])
]),
GameObject('ending_room')
], [GameObject('key')],
[
GamePassage(11, 'starting_room',
'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
],
[
GamePassageRevealAction('door', 'key', 11),
GameObjectUseAction('keypart1', 'keypart2',
'key')
], [], 'ending_room', {}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == '')
solution = GameSolver().solve(game_internal)
assert (solution == [['take', 'keypart1'], ['open', 'box'],
['take', 'keypart2'],
['use', 'keypart1', 'keypart2'],
['use', 'door', 'key'], ['go', 'N']])
# Here use action + passage reval view = use passage reveal, so it is just
# pure complication. game10 may make the possibility of the separaton more meaningful.
def test_syntax_checker_good_game9(self):
game_internal = Game(
[[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('key', [])
]),
GameObject('ending_room')
], [GameObject('broken_key')],
[
GamePassage(11, 'starting_room', 'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GameObjectUseAction('door', 'key', 'broken_key')],
[GamePassageRevealAction('broken_key', '', 11)], 'ending_room',
{}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == "")
assert (GameSolver().solve(game_internal) == [['take', 'key'],
['use', 'door', 'key'],
['go', 'N']])
def test_syntax_checker_good_game10(self):
game_internal = Game(
[[
GameObject('starting_room', [], [
GameObject('door', [GameObjectAttribute.IMMOBILE]),
GameObject('key', [])
]),
GameObject('strange_room'),
GameObject('ending_room')
], [GameObject('broken_key')],
[
GamePassage(11, 'starting_room', 'strange_room', 'W', 'E',
[]),
GamePassage(12, 'strange_room', 'ending_room', 'N', 'S',
[GameObjectAttribute.INVISIBLE])
], [GameObjectUseAction('door', 'key', 'broken_key')],
[GamePassageRevealAction('broken_key', '', 12)], 'ending_room',
{}])
verdict = GameSyntaxChecker().check(game_internal)
assert (verdict == "")
assert (GameSolver().solve(game_internal) == [['take', 'key'],
['use', 'door', 'key'],
['go', 'W'], ['go',
'N']])
def test_take_and_drop_existing_object(self):
subject = self.game1.do_it('take', 'candle')
assert (not subject is None)
assert (not self.game1.has('candle') is None)
assert (not 'candle' in self.game1.stuffs())
subject = self.game1.do_it('drop', 'candle')
assert (not subject is None)
assert (self.game1.has('candle') is None)
def test_trying_take_not_existing_object(self):
subject = self.game1.do_it('take', 'banana')
assert (subject is None)
assert (self.game1.has('banana') is None)
def test_trying_take_immobile_object(self):
subject = self.game1.do_it('take', 'table')
assert (subject is None)
assert (self.game1.has('table') is None)
def test_action_hit_the_bird_with_the_stone(self):
self.game1.do_it('take', 'stone')
object1 = self.game1.do_it('use', 'stone', 'bird')
assert (not object1 is None)
assert (not 'bird' in self.game1.stuffs())
assert (self.game1.has('stone') is None)
assert ('injured_bird' in self.game1.stuffs())
object2 = self.game1.do_it('use', 'stone', 'bird')
assert (object2 is None)
def test_action_hit_the_bird_with_the_stone_but_both_are_in_inventory(
self):
self.game1.do_it('take', 'stone')
self.game1.do_it('take', 'bird')
object1 = self.game1.do_it('use', 'stone', 'bird')
assert (not self.game1.has('injured_bird') is None)
def test_action_hit_the_bird_with_the_stone_but_use_params_are_reversed(
self):
self.game1.do_it('take', 'stone')
self.game1.do_it('use', 'bird', 'stone')
assert ('injured_bird' in self.game1.stuffs())
def test_room_goes_light_from_dark_if_we_burn_the_candle_without_taking_it_first(
self):
self.game1.do_it('take', 'match')
self.game1.do_it('use', 'candle', 'match')
assert (not 'candle' in self.game1.stuffs())
assert ('burning_candle' in self.game1.stuffs())
assert ('picture' in self.game1.stuffs())
def test_room_goes_light_from_dark_if_we_burn_the_candle_with_taking_it_first(
self):
self.game1.do_it('take', 'candle')
self.game1.do_it('take', 'match')
self.game1.do_it('use', 'candle', 'match')
assert (not self.game1.has('burning_candle') is None)
assert ('picture' in self.game1.stuffs())
def test_moving_between_rooms(self):
self.game1.do_it('go', 'N')
assert (self.game1.look() == 'bathroom')
assert (self.game1.directions() == [['S', 'dark_room']])
self.game1.do_it('go', 'S')
assert (self.game1.look() == 'dark_room')
def test_opening_objects(self):
self.game1.do_it('go', 'N')
assert (not 'knife' in self.game1.stuffs())
assert (self.game1.do_it('open', 'cabinet'))
assert ('knife' in self.game1.stuffs())
def test_moving_between_rooms_and_carrying_object(self):
subject = self.game1.do_it('take', 'candle')
self.game1.do_it('go', 'N')
self.game1.do_it('drop', 'candle')
self.game1.do_it('go', 'S')
assert (self.game1.look() == 'dark_room')
assert (not 'candle' in self.game1.stuffs())
def test_recognizing_a_new_object_through_a_view_and_it_becomes_permanent(
self):
self.game1.do_it('take', 'match')
object1 = self.game1.do_it('use', 'candle', 'match')
self.game1.do_it('take', 'burning_candle')
self.game1.do_it('go', 'N')
self.game1.do_it('drop', 'burning_candle')
self.game1.do_it('go', 'S')
assert (self.game1.look() == 'dark_room')
assert ('picture' in self.game1.stuffs())
def test_finding_a_new_passage(self):
self.test_recognizing_a_new_object_through_a_view_and_it_becomes_permanent(
)
assert ('picture' in self.game1.stuffs())
self.game1.do_it('use', 'picture')
assert (self.game1.directions() == [['N', 'bathroom'],
['W', 'secret_room']])
def test_winning_the_game(self):
self.test_finding_a_new_passage()
self.game1.do_it('go', 'W')
assert (self.game1.won() == 1)
def test_solver_on_full_game(self):
verdict = GameSyntaxChecker().check(self.game1)
assert (verdict == '')
solution = GameSolver().solve(self.game1)
assert (solution == [['take', 'candle'], ['take', 'match'],
['take', 'bird'], ['take', 'stone'],
['use', 'candle', 'match'],
['use', 'bird', 'stone'], ['use', '', 'picture'],
['go', 'W']])
def test_json_serializer_deserializer(self):
game1_text_blueprints_reconstructed = json.dumps(
self.game1.get_blueprints(), cls=GameEncoder)
array_game_description_reconstructed = GameDecoder().decode(
game1_text_blueprints_reconstructed)
assert (self.game1.get_blueprints() ==
array_game_description_reconstructed)
def test_json_deserializer_serializer(self):
array_game_description = GameDecoder().decode(
self.game1_text_blueprints)
text_game_description2 = json.dumps(array_game_description,
cls=GameEncoder)
array_game_description2 = GameDecoder().decode(text_game_description2)
assert (array_game_description == array_game_description2)
def test_json_game_deserializer_serializer_1(self):
game_internal_text = '[[{"obj_content": {"attributes": [], "childObjects": [], "name": "roomA"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomB"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomC"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomD"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomE"}, "obj_name": "GameObject"},\
{"obj_content": {"attributes": [], "childObjects": [], "name": "roomF"}, "obj_name": "GameObject"}],\
[],\
[{"obj_content": {"room_name2": "roomB", "room_name1": "roomA", "direction2": "S", "attributes": [], "direction1": "N", "identifier": 11},\
"obj_name": "GamePassage"},\
{"obj_content": {"room_name2": "roomE", "room_name1": "roomA", "direction2": "W", "attributes": [], "direction1": "E", "identifier": 12},\
"obj_name": "GamePassage"},\
{"obj_content": {"room_name2": "roomB", "room_name1": "roomE", "direction2": "E", "attributes": [], "direction1": "N", "identifier": 13},\
"obj_name": "GamePassage"},\
{"obj_content": {"room_name2": "roomE", "room_name1": "roomD", "direction2": "S", "attributes": [], "direction1": "N", "identifier": 14},\
"obj_name": "GamePassage"},\
{"obj_content": {"room_name2": "roomF", "room_name1": "roomC", "direction2": "W", "attributes": [], "direction1": "E", "identifier": 15},\
"obj_name": "GamePassage"}], [], [], "roomF", {}]'
game_from_text = Game(GameDecoder().decode(game_internal_text))
game_internal = Game([[
GameObject('roomA'),
GameObject('roomB'),
GameObject('roomC'),
GameObject('roomD'),
GameObject('roomE'),
GameObject('roomF')
], [],
[
GamePassage(11, 'roomA', 'roomB', 'N', 'S'),
GamePassage(12, 'roomA', 'roomE', 'E', 'W'),
GamePassage(13, 'roomE', 'roomB', 'N', 'E'),
GamePassage(14, 'roomD', 'roomE', 'N', 'S'),
GamePassage(15, 'roomC', 'roomF', 'E', 'W')
], [], [], 'roomF', {}])
assert (game_internal == game_from_text)
def test_json_game_deserializer_serializer_2(self):
game_from_text = Game(GameDecoder().decode(self.game1_text_blueprints))
assert (self.game1 == game_from_text)
