def order(self, observations: Observations, step_index: int)-> Order:
if observations.last():
self.qlearn.learn(str(self.previous_state), self.previous_action, observations.reward(), 'terminal')
QLearningTableStorage().save(self.qlearn, self.agent_name)
self.previous_action = None
self.previous_state = None
self.previous_order = None
return NoOrder()
elif observations.first():
self.location = Location(observations)
self.smart_actions = SmartActions(self.location)
self.qlearn = QLearningTable(actions=list(range(len(self.smart_actions.all()))))
QLearningTableStorage().load(self.qlearn, self.agent_name)
self.control_group_order = PrepareSCVControlGroupsOrder(self.location)
if not self.control_group_order.done(observations):
return self.control_group_order
elif not self.previous_order or self.previous_order.done(observations):
current_state = StateBuilder().build_state(self.location, observations)
if self.previous_action is not None:
self.qlearn.learn(str(self.previous_state), self.previous_action, 0, str(current_state))
rl_action = self.qlearn.choose_action(str(current_state))
self.previous_state = current_state
self.previous_action = rl_action
self.previous_order = self.smart_actions.order(rl_action)
return self.previous_order
def step(self, obs):
super(SCVControlGroupsAgent, self).step(obs)
observations = Observations(obs)
if observations.first():
self.base_location = Location(observations)
self.order = PrepareSCVControlGroupsOrder(self.base_location)
print(observations.control_groups())
return self.order.execute(observations)
def step(self, obs):
super(ScoutingAgent, self).step(obs)
observations = Observations(obs)
if observations.first():
base_location = Location(observations)
self.commander = ScoutingCommander(base_location,
self.infinite_scouting)
return self.commander.order(observations,
self.steps).execute(observations)
def order(self, observations: Observations, step_index: int) -> Order:
if observations.first():
self.current_order = self.current_commander.order(observations)
elif self.current_order.done(observations):
if self.current_commander == self.scout_commander:
self.current_commander = self.production_commander
elif self.current_commander == self.production_commander:
self.current_commander = self.army_commander
elif self.current_commander == self.army_commander:
self.current_commander = self.scout_commander
self.current_order = self.current_commander.order(observations)
#print(self.current_order)
return self.current_order
def step(self, obs):
super(ReinforcementMarineAgent, self).step(obs)
observations = Observations(obs)
if observations.first():
self.commander = QLearningCommander(self.name())
elif observations.last():
game_results = GameResultsTable(self.name())
game_info = FinishedGameInformationDetails(self.steps, "unknown")
game_results.append(observations.reward(),
observations.score_cumulative(), game_info)
return self.commander.order(observations,
self.steps).execute(observations)
def step(self, obs):
super(BuildOrderAgent, self).step(obs)
observations = Observations(obs)
if observations.first():
base_location = Location(observations)
self.commander = GameCommander(base_location)
elif observations.last():
game_results = GameResultsTable(self.name())
game_info = FinishedGameInformationDetails(self.steps, "unknown")
game_results.append(observations.reward(),
observations.score_cumulative(), game_info)
if self.debug:
time.sleep(0.5)
return self.commander.order(observations,
self.steps).execute(observations)
def step(self, obs):
super(HybridAttackReinforcementAgent, self).step(obs)
observations = Observations(obs)
if observations.first():
base_location = Location(observations)
self.enemy_detector = EnemyDetector()
self.commander = HybridGameCommander(base_location, self.name(),
self.enemy_detector)
elif observations.last():
game_results = GameResultsTable(self.name())
game_info = FinishedGameInformationDetails(
self.steps, self.enemy_detector.race())
game_results.append(observations.reward(),
observations.score_cumulative(), game_info)
return self.commander.order(observations,
self.steps).execute(observations)
def step(self, obs):
super(SCVHarvesterAgent, self).step(obs)
observations = Observations(obs)
if observations.first():
self.base_location = Location(observations)
self.control_group_order = PrepareSCVControlGroupsOrder(
self.base_location)
self.order_first_refinery = BuildRefinery(self.base_location, 1)
self.order_second_refinery = BuildRefinery(self.base_location, 2)
self.fill_refinery_one_order = FillRefineryOnceBuilt(
self.base_location, 1)
self.fill_refinery_second_order = FillRefineryOnceBuilt(
self.base_location, 2)
self.train_scv_order = BuildSCV(self.base_location)
if not self.control_group_order.done(observations):
action = self.control_group_order.execute(observations)
elif not self.order_first_refinery.done(observations):
action = self.order_first_refinery.execute(observations)
elif not self.order_second_refinery.done(observations):
action = self.order_second_refinery.execute(observations)
elif self.fill_refinery_one_order.doable(
observations
) and not self.fill_refinery_one_order.done(observations):
action = self.fill_refinery_one_order.execute(observations)
elif self.fill_refinery_second_order.doable(
observations
) and not self.fill_refinery_second_order.done(observations):
action = self.fill_refinery_second_order.execute(observations)
elif self.train_scv_order.doable(
observations) and not self.train_scv_order.done(observations):
action = self.train_scv_order.execute(observations)
elif self.train_scv_order.doable(
observations) and self.train_scv_order.done(observations):
self.train_scv_order = BuildSCV(self.base_location)
action = self.train_scv_order.execute(observations)
else:
action = NoOrder().execute(observations)
if self.debug:
time.sleep(0.5)
return action