def create(cls, game, name, alias):
d = Direction(game, name)
Action.create(game=game,
name=name,
aliases=[alias],
callback=lambda schema: schema[Role.AGENT].go(d))
return d
def __handle(event, context) -> Tuple[Optional[Dict[Any, Any]], Optional[str]]:
"""
Handles incoming event by invoking a specific action according to a request type.
:param event: Invocation event.
:param context: Invocation context.
:return: A tuple containing two items:
1. Custom data to return back to CloudFormation service (can be empty).
2. Physical resource id (can be empty).
"""
serialized_event = json.dumps(event,
default=lambda o: "<not serializable>")
logger.info(f"Got new request. Event: {serialized_event}.")
action = Action(event)
if event["RequestType"] == "Create":
return action.create()
if event["RequestType"] == "Update":
return action.update()
if event["RequestType"] == "Delete":
return action.delete()
raise KeyError("Unsupported request type! Type: {}".format(
event["RequestType"]))
def _createAction(self, stateDir, logDir, generalHarvestLog):
return Action.create(self, stateDir=stateDir, logDir=logDir, generalHarvestLog=generalHarvestLog)
def setup_actions(self, game):
Action.create(
game,
name='history',
callback=lambda schema: schema[Role.AGENT].game.history())
Action.create(game,
name='help',
callback=lambda schema: schema[Role.AGENT].game.help())
Action.create(game,
name='status',
aliases=['score'],
callback=lambda schema: schema[Role.AGENT].game.status())
Action.create(game,
name='exit',
aliases=['quit', 'end', 'done'],
callback=lambda schema: game.exit_game())
Action.create(game,
name='diagnose',
callback=lambda schema: schema[Role.AGENT].diagnose())
Action.create(game,
name='wait',
callback=lambda schema: Success("Time passes..."))
Action.create(
game,
name='inventory',
aliases=['i'],
callback=lambda schema: schema[Role.AGENT].list_inventory())
Action.create(game,
name='look',
aliases=['l'],
direct_object_role=Role.THEME,
preposition_roles={
'at': Role.THEME,
'in': Role.THEME,
'on': Role.THEME
},
callback=lambda schema: schema[Role.AGENT].look(schema[
Role.THEME]))
def process_get(schema):
if schema[Role.PATIENT]:
r = schema[Role.AGENT].get_from(schema[Role.THEME],
schema[Role.PATIENT])
else:
theme = schema[Role.THEME]
if isinstance(theme, Creature) and not theme.traits.portable:
r = Failure(
"You are unable to subdue and capture the {}!".format(
theme.full_name()))
elif not theme.traits.portable:
r = Failure(
"The {} is solidly anchored and cannot be removed".
format(theme.full_name()))
else:
r = schema[Role.AGENT].get(schema[Role.THEME])
return r
Action.create(
game,
name='get',
aliases=['take'],
required_roles={Role.AGENT},
direct_object_role=Role.THEME,
preposition_roles={'from': Role.PATIENT},
role_scopes={
Role.THEME: Scope.EXTERNAL,
Role.PATIENT: Scope.EXTERNAL
},
role_messages={
Role.THEME:
"Admire the {} all you want, you can't take it with you."
},
callback=process_get)
Action.create(game,
name='drop',
aliases=['leave'],
direct_object_role=Role.THEME,
required_roles={Role.AGENT, Role.THEME},
role_scopes={Role.THEME: Scope.INVENTORY},
callback=lambda schema: schema[Role.AGENT].drop(schema[
Role.THEME]))
Action.create(
game,
name='go',
aliases=['walk'],
required_roles={Role.AGENT, Role.GOAL},
direct_object_role=Role.GOAL,
role_messages={Role.GOAL: "That's not a direction!"},
callback=lambda schema: schema[Role.AGENT].go(schema[Role.GOAL]))
Action.create(game,
name='open',
required_roles={Role.AGENT, Role.PATIENT},
direct_object_role=Role.PATIENT,
callback=lambda schema: schema[Role.AGENT].open(schema[
Role.PATIENT]))
Action.create(game,
name='close',
required_roles={Role.AGENT, Role.PATIENT},
direct_object_role=Role.PATIENT,
callback=lambda schema: schema[Role.AGENT].close(schema[
Role.PATIENT]))
Action.create(
game,
name='lock',
required_roles={Role.AGENT, Role.PATIENT, Role.INSTRUMENT},
direct_object_role=Role.PATIENT,
preposition_roles={'with': Role.INSTRUMENT},
callback=lambda schema: schema[Role.AGENT].lock_with(
schema[Role.PATIENT], schema[Role.INSTRUMENT]))
Action.create(
game,
name='unlock',
required_roles={Role.AGENT, Role.PATIENT, Role.INSTRUMENT},
direct_object_role=Role.PATIENT,
preposition_roles={'with': Role.INSTRUMENT},
callback=lambda schema: schema[Role.AGENT].unlock_with(
schema[Role.PATIENT], schema[Role.INSTRUMENT]))
Action.create(game,
name='put',
required_roles={Role.AGENT, Role.PATIENT, Role.THEME},
direct_object_role=Role.THEME,
preposition_roles={
'in': Role.PATIENT,
'into': Role.PATIENT,
'on': Role.PATIENT
},
callback=lambda schema: schema[Role.AGENT].put_in(
schema[Role.THEME], schema[Role.PATIENT]))
Action.create(
game,
name='eat',
required_roles={Role.AGENT, Role.THEME},
direct_object_role=Role.THEME,
role_messages={
Role.THEME: "I don't think the {} would agree with you."
},
callback=lambda schema: schema[Role.AGENT].eat(schema[Role.THEME]))
Action.create(game,
name='drink',
required_roles={Role.AGENT, Role.THEME},
direct_object_role=Role.THEME,
role_messages={
Role.THEME:
"I don't think the {} would agree with you."
},
callback=lambda schema: schema[Role.AGENT].drink(schema[
Role.THEME]))
Action.create(game,
name='greet',
required_roles={Role.AGENT, Role.PATIENT},
direct_object_role=Role.PATIENT,
callback=lambda schema: schema[Role.AGENT].greet(schema[
Role.PATIENT]))
Action.create(game,
name='smile',
required_roles={Role.AGENT, Role.PATIENT},
preposition_roles={'at': Role.PATIENT},
callback=lambda schema: schema[Role.AGENT].greet(schema[
Role.PATIENT]))
Action.create(game,
name='wave',
required_roles={Role.AGENT, Role.PATIENT},
preposition_roles={
'at': Role.PATIENT,
'to': Role.PATIENT
},
callback=lambda schema: schema[Role.AGENT].greet(schema[
Role.PATIENT]))
Action.create(game,
name='give',
aliases=['offer'],
required_roles={Role.AGENT, Role.PATIENT, Role.THEME},
direct_object_role=Role.THEME,
indirect_object_role=Role.PATIENT,
preposition_roles={'to': Role.PATIENT},
callback=lambda schema: schema[Role.AGENT].give_to(
schema[Role.THEME], schema[Role.PATIENT]))
Action.create(game,
name='ask',
required_roles={Role.AGENT, Role.PATIENT, Role.THEME},
direct_object_role=Role.PATIENT,
preposition_roles={'for': Role.THEME},
callback=lambda schema: schema[Role.AGENT].ask_for(
schema[Role.PATIENT], schema[Role.THEME]))
Action.create(
game,
name='kill',
aliases=['attack', 'fight', 'hit'],
required_roles={Role.AGENT, Role.PATIENT, Role.INSTRUMENT},
direct_object_role=Role.PATIENT,
preposition_roles={'with': Role.INSTRUMENT},
role_messages={
Role.INSTRUMENT:
"The {} proves an ineffective choice of weapon"
},
callback=lambda schema: schema[Role.AGENT].hit_with(
schema[Role.PATIENT], schema[Role.INSTRUMENT]))
def process_throw(schema):
if schema[Role.GOAL]:
r = schema[Role.AGENT].throw(schema[Role.THEME],
schema[Role.GOAL])
else:
r = schema[Role.AGENT].throw(schema[Role.THEME])
return r
Action.create(
game,
name='throw',
aliases=['toss', 'pitch', 'fling', 'lob'],
required_roles={Role.AGENT, Role.THEME},
direct_object_role=Role.THEME,
role_scopes={
Role.THEME: Scope.INVENTORY,
Role.PATIENT: Scope.EXTERNAL
},
preposition_roles={
'at': Role.GOAL,
'to': Role.GOAL
},
role_messages={
Role.THEME:
"The {} is too unwieldy to make an effective missile",
Role.GOAL: "The {} is not intended for target practice!"
},
callback=lambda schema: process_throw(schema))
Action.create(
game,
name='smell',
required_roles={Role.AGENT, Role.THEME},
direct_object_role=Role.THEME,
permissive_roles={Role.THEME},
callback=lambda schema: Success("Smells like {} {} to me!".format(
schema[Role.THEME].article(), schema[Role.THEME].full_name())))
Action.create(game,
name='listen',
required_roles={Role.AGENT, Role.THEME},
permissive_roles={Role.THEME},
preposition_roles={'to': Role.THEME},
callback=lambda schema: Success(
"The {} is keeping pretty quiet right now".format(
schema[Role.THEME].full_name())))
Action.create(game,
name='admire',
aliases=['appreciate'],
direct_object_role=Role.THEME,
required_roles={Role.AGENT, Role.THEME},
permissive_roles={Role.THEME},
callback=lambda schema: Success(
"Breathtaking! You feel enriched by this profound "
"artistic experience."))
jump_result = Success("You take a great leap into the air")
jump_result.add_message("Wheeeeeee!")
jump_result.add_message("Boing boing boing ...")
jump_result.add_message("Up, up and away!")
def process_jump(schema):
return jump_result
Action.create(game,
name='jump',
required_roles={Role.AGENT},
callback=process_jump)
def setUp(self):
self.thing = Thing(name='thing')
self.action1 = Action.create(name='action1')
self.action2 = Action.create(name='action2')
self.thing.add_agent_role(verb='action1')
print('[admin]')
for key, value in admin_account.items():
print(key + ' : ' + '*' * len(value) if key == 'pwd' else key + ' : ' +
value)
print('\n[user]')
for key, value in user_account.items():
print(key + ' : ' + '*' * len(value) if key == 'pwd' else key + ' : ' +
value)
# 最終確認
print(f"""
host : {host}
port : {port}
ini dir : {ini_dir}
""")
while True:
confirm = input('OK? y/n(exit) >>')
if confirm == 'n':
sys.exit('exit')
elif confirm == 'y':
break
else:
continue
# DB作成
Action.create(admin_account, user_account, ini_dir, host, port)
# テスト用のためにここに置く
# db.destroy(user_account, host, port, admin=admin_account, del_user=True)
