def test_match_false_body():
template = Template()
template.body = "Hello World"
message = Message()
assert not template.match(message)
message.body = "Bye Bye Love"
assert not template.match(message)
async def run(self):
print("InformBehav running")
msg = Message(to=self.agent.recv_jid) # Instantiate the message
msg.set_metadata("performative", "inform") # Set the "inform" FIPA performative
msg.body = "Hello World {}".format(self.agent.recv_jid) # Set the message content
await self.send(msg)
print("Message sent!")
# stop agent from behaviour
await self.agent.stop()
def test_behaviour_match_without_template():
class TestBehaviour(OneShotBehaviour):
async def run(self):
pass
behaviour = TestBehaviour()
msg = Message()
msg.sender = "sender1@host"
msg.to = "recv1@host"
msg.body = "Hello World"
msg.thread = "thread-id"
msg.set_metadata("performative", "query")
assert behaviour.match(msg)
def test_match():
template = Template()
template.sender = "sender1@host"
template.to = "recv1@host"
template.body = "Hello World"
template.thread = "thread-id"
template.metadata = {"performative": "query"}
message = Message()
message.sender = "sender1@host"
message.to = "recv1@host"
message.body = "Hello World"
message.thread = "thread-id"
message.set_metadata("performative", "query")
assert template.match(message)
async def run(self):
if self.agent.has_message:
print(
f"SenderAgent: running at {datetime.datetime.now().time()}: {self.counter}"
)
msg = Message(
to=self.agent.recv_jid) # Instantiate the message
msg.set_metadata(
"performative",
"inform") # Set the "inform" FIPA performative
msg.body = str(f"{self.agent.message_to_send}")
await self.send(msg)
print("SenderAgent: Message sent!")
self.counter += 1
msg = await self.receive(timeout=10)
if msg:
print("SenderAgent: Response Message received: {}".format(
msg.body))
if self.agent.to_send:
self.agent.response_classification_message = msg.body
else:
self.agent.response_extraction_message = msg.body
else:
print(
"SenderAgent: Did not received any response message after 10 seconds"
)
self.agent.has_message = False
async def run(self):
################## recive the value from the RandomWlaker ##################
#print("RecvBehav running [ CarefulAgent ]")
msg = await self.receive(timeout=20)
# we use str() to convert the type of msg.sender
if msg and str(msg.sender) == self.randomWalker:
value = int(msg.body)
print("CarefulAgent : c'est trop :" + str(value))
random_value = random.randint(0, value)
print("CarefulAgent : je vais vous donner :" +
str(random_value) + "\n")
####### sent the value ################
msg = Message(to=self.randomWalker) # Instantiate the message
msg.set_metadata(
"performative",
"inform") # Set the "inform" FIPA performative
msg.body = str(random_value) # Set the message content
await asyncio.sleep(10) # wait 10 seconds
await self.send(msg)
else:
print(
"Did not received any message after 20 seconds [[ Message from agent CarefulAgent ]]"
)
async def run(self):
msg = Message()
msg.set_metadata('performative', 'sight')
msg.to = self.agent.name
msg.body = "NAME: " + self.agent.name
self.send(msg)
msgSight = await self.receive(10000)
if not msgSight:
self.agent.m_AimedAgent = None
return
sContent = msgSight.body
tokens = sContent.split()
iNumOfObjects = int(tokens[1])
self.agent.m_FOVObjects = []
if iNumOfObjects <= 0:
self.agent.m_AimedAgent = None
return
tokens = tokens[2:]
for i in range(iNumOfObjects):
s = CSight()
s.m_id = i
s.m_eTeam = int(tokens[1])
s.m_eType = int(tokens[3])
s.m_dAngle = float(tokens[5])
s.m_dDistance = float(tokens[7])
s.m_iHealth = int(tokens[9])
s.m_Position.x = float(tokens[11])
s.m_Position.y = float(tokens[13])
s.m_Position.z = float(tokens[15])
self.agent.m_FOVObjects.append(s)
def prepare_power_data_response(self, power, receivers):
msg = Message(to=receivers)
msg.set_metadata('performative', 'inform')
msg.set_metadata('type', 'power_data')
msg.body = json.dumps({'power': power})
return msg
async def late_confirm(self, behav, confirmed, receiver):
late_confirm = Message(to=receiver)
late_confirm.set_metadata('performative', 'inform')
late_confirm.set_metadata('type', 'move_meeting_inform')
late_confirm.body = json.dumps({"confirmed": confirmed})
await behav.send(late_confirm)
async def run(self):
def check(x):
if x[1] is None:
return float('Inf')
else:
return x[1]
meeting_impossible = True
for key, meeting_scr in self.agent.meetings_info[
self.meeting_guid]["scores"].items():
if meeting_scr is not None:
meeting_impossible = False
meeting = self.agent.meetings_info[self.meeting_guid]
if meeting_impossible:
organizer_response = Message(to=meeting["organizer_jid"])
organizer_response.set_metadata('performative', 'refuse')
organizer_response.set_metadata('type', 'meet_refuse')
organizer_response.body = json.dumps({
'meeting_guid':
self.meeting_guid,
'start_date':
time_to_str(meeting['start_date']),
'end_date':
time_to_str(meeting['end_date']),
'room_id':
meeting['room_id'],
'temperature':
meeting['temperature']
})
await self.send(organizer_response)
self.agent.processing_meeting = False
return
room_date = min(
self.agent.meetings_info[self.meeting_guid]["scores"].items(),
key=check)
if not runtime_switches.is_best_room_selected_for_meeting:
for key, meeting_scr in self.agent.meetings_info[
self.meeting_guid]["scores"].items():
if meeting_scr is not None:
room_date = [key, meeting_scr]
self.agent.meetings_info[
self.meeting_guid]["room_id"] = room_date[0]
for receiver in meeting.get('participants'):
response = Message()
response.set_metadata('performative', 'inform')
response.set_metadata('type', 'new_meeting_inform')
response.body = json.dumps({
'meeting_guid':
self.meeting_guid,
'organizer_jid':
meeting["organizer_jid"],
'start_date':
time_to_str(meeting['start_date']),
'end_date':
time_to_str(meeting['end_date']),
'room_id':
meeting['room_id'],
'temperature':
meeting['temperature']
})
response.to = receiver
await self.send(response)
response = Message()
response.set_metadata('performative', 'inform')
response.set_metadata('type', 'new_meeting_inform')
response.body = json.dumps({
'meeting_guid':
self.meeting_guid,
'organizer_jid':
meeting["organizer_jid"],
'start_date':
time_to_str(meeting['start_date']),
'end_date':
time_to_str(meeting['end_date']),
'room_id':
meeting['room_id'],
'temperature':
meeting['temperature']
})
response.to = str(meeting['room_id'])
await self.send(response)
self.agent.meeting_room_calendars[meeting['room_id']].add_event(
self.meeting_guid, meeting['start_date'], meeting['end_date'],
meeting['temperature'])
organizer_response = Message(to=meeting["organizer_jid"])
organizer_response.set_metadata('performative', 'inform')
organizer_response.set_metadata('type', 'meet_inform')
organizer_response.body = json.dumps({
'meeting_guid':
self.meeting_guid,
'start_date':
time_to_str(meeting['start_date']),
'end_date':
time_to_str(meeting['end_date']),
'room_id':
meeting['room_id'],
'temperature':
meeting['temperature']
})
await self.send(organizer_response)
self.agent.processing_meeting = False
if runtime_switches.log_level >= 0:
print("Meeting with GUID ", self.meeting_guid,
" was scheduled in room ", meeting['room_id'], " from ",
meeting['start_date'], " to ", meeting['end_date'],
" with temperature ", meeting['temperature'])
async def CheckObjectsAtStep(self, _idAgent, behaviour):
if len(self.m_DinObjectList) <= 0:
return
if self.m_AgentList[_idAgent].m_iHealth <= 0:
return
WIDE = 3
xmin = self.m_AgentList[_idAgent].m_Locate.m_Position.x - WIDE
zmin = self.m_AgentList[_idAgent].m_Locate.m_Position.z - WIDE
xmax = self.m_AgentList[_idAgent].m_Locate.m_Position.x + WIDE
zmax = self.m_AgentList[_idAgent].m_Locate.m_Position.z + WIDE
for DinObject in self.m_DinObjectList.values():
if DinObject.m_eType == CPack.PACK_MEDICPACK and self.m_AgentList[_idAgent].m_iHealth >= 100: continue
if DinObject.m_eType == CPack.PACK_AMMOPACK and self.m_AgentList[_idAgent].m_iAmmo >= 100: continue
if DinObject.m_eType == CPack.PACK_OBJPACK and DinObject.m_bTaken and DinObject.m_Owner >0: continue
if DinObject.m_Position.x >= xmin and DinObject.m_Position.x <= xmax \
and DinObject.m_Position.z >= zmin and DinObject.m_Position.z <= zmax:
# Agent has stepped on pack
bSend = False
id = DinObject.m_JID
iQty = 0
eType = DinObject.m_eType
owner = DinObject.m_JID
sContent = ""
# Statistics
eTeam = self.m_AgentList[_idAgent].m_eTeam
if DinObject.m_eTeam == CTroop.TEAM_ALLIED:
ePackTeam = 0
else: ePackTeam = 1
if DinObject.m_eType == CPack.PACK_MEDICPACK:
# Statistics
if DinObject.m_eTeam == eTeam:
self.m_GameStatistic.m_tTeamStatistic[ePackTeam].m_iPacks[0].m_iTeamTaken=\
self.m_GameStatistic.m_tTeamStatistic[ePackTeam].m_iPacks[0].m_iTeamTaken+1
else:
self.m_GameStatistic.m_tTeamStatistic[ePackTeam].m_iPacks[0].m_iEnemyTaken=\
self.m_GameStatistic.m_tTeamStatistic[ePackTeam].m_iPacks[0].m_iEnemyTaken+1
iQty = 20
try:
del self.m_DinObjectList[id]
print (self.m_AgentList[_idAgent].m_JID + ": got a medic pack " + str(DinObject.m_JID))
sContent = " TYPE: " + str(eType) + " QTY: " + str(iQty) + " "
bSend = True
except:
print("NO SE PUEDE BORRAR LA CLAVE")
elif DinObject.m_eType == CPack.PACK_AMMOPACK:
# Statistics
if DinObject.m_eTeam == eTeam:
self.m_GameStatistic.m_tTeamStatistic[ePackTeam].m_iPacks[1].m_iTeamTaken=\
self.m_GameStatistic.m_tTeamStatistic[ePackTeam].m_iPacks[1].m_iTeamTaken+1
else:
self.m_GameStatistic.m_tTeamStatistic[ePackTeam].m_iPacks[1].m_iEnemyTaken=\
self.m_GameStatistic.m_tTeamStatistic[ePackTeam].m_iPacks[1].m_iEnemyTaken+1
iQty = 20
try:
del self.m_DinObjectList[id]
print (self.m_AgentList[_idAgent].m_JID + ": got an ammo pack " + str(DinObject.m_JID))
sContent = " TYPE: " + str(eType) + " QTY: " + str(iQty) + " "
bSend = True
except:
print("NO SE PUEDE BORRAR LA CLAVE")
elif DinObject.m_eType == CPack.PACK_OBJPACK:
if self.m_AgentList[_idAgent].m_eTeam == CTroop.TEAM_ALLIED:
print(self.m_AgentList[_idAgent].m_JID + ": got the objective pack " + str(DinObject.m_JID))
DinObject.m_bTaken = True
DinObject.m_Owner = _idAgent
DinObject.m_Position.x = DinObject.m_Position.y = DinObject.m_Position.z = 0.0
self.m_AgentList[_idAgent].m_bCarryingObjective = True
sContent = " TYPE: " + str(eType) + " QTY: 0 TEAM: ALLIED "
bSend = True
# Statistics
self.m_GameStatistic.m_tTeamStatistic[0].m_iTotalObjectiveTaken = \
self.m_GameStatistic.m_tTeamStatistic[0].m_iTotalObjectiveTaken + 1
self.m_GameStatistic.m_tTeamStatistic[1].m_iTotalObjectiveLost = \
self.m_GameStatistic.m_tTeamStatistic[1].m_iTotalObjectiveLost + 1
elif self.m_AgentList[_idAgent].m_eTeam == CTroop.TEAM_AXIS:
if DinObject.m_bTaken:
print (self.m_AgentList[_idAgent].m_JID + ": returned the objective pack " + str(DinObject.m_JID))
DinObject.m_bTaken = False
DinObject.m_Owner = 0
DinObject.m_Position.x =self.m_Map.GetTargetX()
DinObject.m_Position.y =self.m_Map.GetTargetY()
DinObject.m_Position.z =self.m_Map.GetTargetZ()
sContent = " TYPE: " + str(eType) + " QTY: 0 TEAM: AXIS "
bSend = True
# Statistics
self.m_GameStatistic.m_tTeamStatistic[1].m_iTotalObjectiveTaken=\
self.m_GameStatistic.m_tTeamStatistic[1].m_iTotalObjectiveTaken+1
else:
sContent = " TYPE: " + str(CPack.PACK_NONE) + " QTY: 0 "
#// Send a destroy/taken msg to pack and an inform msg to agent
if bSend:
msg = Message(to=owner)
msg.set_metadata("performative", "pack_taken")
msg.body=sContent
await behaviour.send(msg)
msg = Message(to=self.m_AgentList[_idAgent].m_AID)
msg.set_metadata("performative", "pack_taken")
msg.body = sContent
await behaviour.send(msg)
def test_body_set_not_string():
msg = Message()
with pytest.raises(TypeError):
msg.body = 1000
async def run(self):
msg = await self.receive(timeout=LONG_RECEIVE_WAIT)
if msg:
content = json.loads(msg.body)
shooter_id = content[NAME]
aim = int(content[AIM])
shots = int(content[SHOTS])
victim_pos = Vector3D(x=content[X],
y=content[Y],
z=content[Z])
try:
shooter = self.agent.agents[shooter_id]
except KeyError:
return
victim = self.agent.shoot(shooter_id, victim_pos)
self.agent.game_statistic.shoot(victim, shooter.team)
if victim is None:
return
damage = 2 if shooter.type == CLASS_SOLDIER else 1
damage *= shots
victim.health -= damage
logger.info("Victim hit: {}".format(victim))
if victim.health <= 0:
victim.health = 0
logger.info("Agent {} died.".format(victim.jid))
if victim.is_carrying_objective:
victim.is_carrying_objective = False
logger.info(
"Agent {} lost the ObjectivePack.".format(
victim.jid))
for din_object in self.agent.din_objects.values():
if din_object.type == PACK_OBJPACK:
din_object.is_taken = False
din_object.owner = 0
msg_pack = Message(to=str(din_object.jid))
msg_pack.set_metadata(
PERFORMATIVE, PERFORMATIVE_PACK_LOST)
din_object.position.x = victim.locate.position.x
din_object.position.y = victim.locate.position.y
din_object.position.z = victim.locate.position.z
msg_pack.body = json.dumps({
X:
victim.locate.position.x,
Y:
victim.locate.position.y,
Z:
victim.locate.position.z,
})
await self.send(msg_pack)
# Statistics
self.agent.game_statistic.objective_lost(
victim.team)
break
msg_shot = Message(to=victim.jid)
msg_shot.set_metadata(PERFORMATIVE, PERFORMATIVE_SHOOT)
msg_shot.body = json.dumps({DEC_HEALTH: damage})
await self.send(msg_shot)
def test_body_set_none():
msg = Message()
msg.body = None
async def run(self):
res = await self.receive(timeout=10000)
msg = Message(to="objective1@localhost")
msg.set_metadata("performative", "inform")
msg.body = "Hello"
await self.send(msg)
async def run(self):
print("I'm at state one (initial state)")
msg = Message(to=str(self.agent.jid))
msg.body = "msg_from_state_one_to_state_three"
await self.send(msg)
self.set_next_state(STATE_TWO)
async def run(self):
try:
if not self.agent.movement:
return
content = {NAME: self.agent.name,
X: self.agent.movement.position.x,
Y: self.agent.movement.position.y,
Z: self.agent.movement.position.z,
VEL_X: self.agent.movement.velocity.x,
VEL_Y: self.agent.movement.velocity.y,
VEL_Z: self.agent.movement.velocity.z,
HEAD_X: self.agent.movement.heading.x,
HEAD_Y: self.agent.movement.heading.y,
HEAD_Z: self.agent.movement.heading.z,
HEALTH: self.agent.health,
AMMO: self.agent.ammo}
msg = Message(to=self.agent.manager)
msg.set_metadata(PERFORMATIVE, PERFORMATIVE_DATA)
msg.body = json.dumps(content)
await self.send(msg)
info = await self.receive(LONG_RECEIVE_WAIT)
if info is None:
return
info = json.loads(info.body)
packs = info[PACKS] if info[PACKS] is not None else []
for pack in packs:
pack = json.loads(pack)
quantity = pack[QTY]
type_ = pack[TYPE]
self.agent.pack_taken(pack_type=type_, quantity=quantity)
self.agent.fov_objects = []
fovs = info[FOV] if info[FOV] is not None else []
if len(fovs) <= 0:
self.agent.aimed_agent = None
else:
for idx, obj in enumerate(fovs):
s = Sight()
s.sight_id = idx
s.team = int(obj[TEAM])
s.type = int(obj[TYPE])
s.angle = float(obj[ANGLE])
s.distance = float(obj[DISTANCE])
s.health = int(obj[HEALTH])
s.position.x = float(obj[X])
s.position.y = float(obj[Y])
s.position.z = float(obj[Z])
self.agent.fov_objects.append(s)
if s.team == TEAM_NONE:
self.agent.bdi.set_belief(PACKS_IN_FOV, idx, int(obj[TYPE]), float(obj[ANGLE]),
float(obj[DISTANCE]), int(obj[HEALTH]), tuple((float(obj[X]), float(obj[Y]), float(obj[Z]))))
elif s.team == self.agent.team:
self.agent.bdi.set_belief(FRIENDS_IN_FOV, idx, int(obj[TYPE]), float(obj[ANGLE]),
float(obj[DISTANCE]), int(obj[HEALTH]), tuple((float(obj[X]), float(obj[Y]), float(obj[Z]))))
else:
self.agent.bdi.set_belief(ENEMIES_IN_FOV, idx, int(obj[TYPE]), float(obj[ANGLE]),
float(obj[DISTANCE]), int(obj[HEALTH]), tuple((float(obj[X]), float(obj[Y]), float(obj[Z]))))
except ZeroDivisionError:
pass
def prep_msg(to, meta_key, meta_value, msg_body):
msg_to_send = Message(to=str(to))
msg_to_send.set_metadata(meta_key, meta_value)
msg_to_send.body = msg_body
return msg_to_send
def prepare_temperature_at_inform(receivers, guid, temperature):
msg = Message(to=receivers)
msg.set_metadata('performative', 'inform')
msg.set_metadata('type', 'temperature_at_inform')
msg.body = json.dumps({'request-guid': guid, 'temperature': temperature})
return msg
def test_body_set_string():
msg = Message()
msg.body = "body"
async def check_objects_at_step(self, id_agent, behaviour):
if len(self.din_objects) <= 0:
return
if self.agents[id_agent].health <= 0:
return
xmin = self.agents[id_agent].locate.position.x - WIDTH
zmin = self.agents[id_agent].locate.position.z - WIDTH
xmax = self.agents[id_agent].locate.position.x + WIDTH
zmax = self.agents[id_agent].locate.position.z + WIDTH
packs = []
keys = list(self.din_objects.keys())
for key in keys:
if key not in self.din_objects:
continue
din_object = self.din_objects[key]
if (din_object.type == PACK_MEDICPACK
and self.agents[id_agent].health >= 100):
continue
if din_object.type == PACK_AMMOPACK and self.agents[
id_agent].ammo >= 100:
continue
if (din_object.type == PACK_OBJPACK and din_object.is_taken
and din_object.owner != 0):
continue
if (xmin <= din_object.position.x <= xmax
and zmin <= din_object.position.z <= zmax):
# Agent has stepped on pack
id_ = din_object.jid
type_ = din_object.type
owner = str(din_object.jid)
content = None
team = self.agents[id_agent].team
self.game_statistic.pack_taken(din_object, team)
if din_object.type == PACK_MEDICPACK:
quantity = DEFAULT_PACK_QTY
try:
del self.din_objects[id_]
logger.info(self.agents[id_agent].jid +
": got a medic pack " +
str(din_object.jid))
content = {TYPE: type_, QTY: quantity}
except KeyError:
logger.error(
"Could not delete the din object {}".format(id_))
elif din_object.type == PACK_AMMOPACK:
quantity = DEFAULT_PACK_QTY
try:
del self.din_objects[id_]
logger.info(self.agents[id_agent].jid +
": got an ammo pack " +
str(din_object.jid))
content = {TYPE: type_, QTY: quantity}
except KeyError:
logger.error(
"Could not delete the din object {}".format(id_))
elif din_object.type == PACK_OBJPACK:
if team == TEAM_ALLIED:
logger.info("{}: got the objective pack ".format(
self.agents[id_agent].jid))
din_object.is_taken = True
din_object.owner = id_agent
(
din_object.position.x,
din_object.position.y,
din_object.position.z,
) = (0.0, 0.0, 0.0)
self.agents[id_agent].is_carrying_objective = True
content = {TYPE: type_, QTY: 0, TEAM: TEAM_ALLIED}
elif team == TEAM_AXIS:
if din_object.is_taken:
logger.info(
f"{self.agents[id_agent].jid}: returned the objective pack {din_object.jid}"
)
din_object.is_taken = False
din_object.owner = 0
din_object.position.x = self.map.get_target_x()
din_object.position.y = self.map.get_target_y()
din_object.position.z = self.map.get_target_z()
content = {TYPE: type_, QTY: 0, TEAM: TEAM_AXIS}
# // Send a destroy/taken msg to pack and an inform msg to agent
if content:
content = json.dumps(content)
msg = Message(to=owner)
msg.set_metadata(PERFORMATIVE, PERFORMATIVE_PACK_TAKEN)
msg.body = content
await behaviour.send(msg)
packs.append(content)
return packs
def test_body_set_not_string():
msg = Message()
with pytest.raises(TypeError):
msg.body = 1000
def get_message(agent, us_data: UserStrategyData):
print("Sending data to {}".format(agent))
msg = Message(names_to_addresses[agent])
msg.set_metadata("performative", "inform")
msg.body = us_data
return msg
async def run(self):
msg = await self.receive(True)
if msg:
sContent = msg.body
tokens = sContent.split()
id = int(tokens[1])
iAim = int(tokens[3])
iShots = int(tokens[5])
iShooterID = 0
for agent in self.agent.m_AgentList.values():
if agent.m_JID == id:
iShooterID = agent.m_JID
break
if iShooterID == 0:
return
# Statistics
if self.agent.m_AgentList[iShooterID].m_eTeam == CTroop.TEAM_ALLIED:
eTeam = 0
else:
eTeam = 1
self.agent.m_GameStatistic.m_tTeamStatistic[eTeam].m_iTotalShots += 1
Victim = self.agent.Shot(id)
if Victim is None:
# Statistics
self.agent.m_GameStatistic.m_tTeamStatistic[eTeam].m_iFailedShots += 1
return
# Statistics
if self.agent.m_AgentList[iShooterID].m_eTeam == Victim.m_eTeam:
self.agent.m_GameStatistic.m_tTeamStatistic[eTeam].m_iTeamHitShots += 1
else:
self.agent.m_GameStatistic.m_tTeamStatistic[eTeam].m_iEnemyHitShots += 1
iDamage = 2
if self.agent.m_AgentList[iShooterID].m_eType == CTroop.CLASS_SOLDIER:
iDamage = 3
msgShot = Message(to=Victim.m_JID)
msgShot.set_metadata("performative", "shot")
msgShot.body = "DEC_HEALTH: " + str(iDamage)
await self.send(msgShot)
self.agent.m_AgentList[Victim.m_JID].m_iHealth -= iDamage
if self.agent.m_AgentList[Victim.m_JID].m_iHealth <= 0:
self.agent.m_AgentList[Victim.m_JID].m_iHealth = 0
print("Agent", str(self.agent.m_AgentList[Victim.m_JID].m_sName), "died")
if self.agent.m_AgentList[Victim.m_JID].m_bCarryingObjective == True:
self.agent.m_AgentList[Victim.m_JID].m_bCarryingObjective = False
print("Agent", str(self.agent.m_AgentList[Victim.m_JID].m_sName), "lost the ObjectivePack")
for DinObject in self.agent.m_DinObjectList.values():
if DinObject.m_eType == CPack.PACK_OBJPACK:
#Esto sobra: DinObject.m_bTaken = false;
DinObject.m_Owner = 0
msgPack = Message(to=DinObject.m_JID)
msgPack.set_metadata("performative", "pack_lost")
DinObject.m_Position.x = self.agent.m_AgentList[Victim.m_id].m_Locate.m_Position.x
DinObject.m_Position.y = self.agent.m_AgentList[Victim.m_id].m_Locate.m_Position.y
DinObject.m_Position.z = self.agent.m_AgentList[Victim.m_id].m_Locate.m_Position.z
msgPack.body = "POSITION: ( " + \
str(self.agent.m_AgentList[Victim.m_id].m_Locate.m_Position.x) + \
" , " + \
str(self.agent.m_AgentList[Victim.m_id].m_Locate.m_Position.y) + \
" , " + \
str(self.agent.m_AgentList[Victim.m_id].m_Locate.m_Position.z) + \
" ) "
await self.send(msgPack)
# Statistics
self.agent.m_GameStatistic.m_tTeamStatistic[0].m_iTotalObjectiveLost += 1
async def run(self):
"""Behavior main function.
Sends messages to ChatAgent or ImageAgent.
"""
logger.debug("DispatcherBehav running")
if self.agent.pipe.poll(): # Avoid blocking thread
bot_msg = self.agent.pipe.recv() # Blocking
logger.info(
"[DispatcherBehav] Received msg from DASI Bot: {}".format(
bot_msg))
assert type(bot_msg) == dict
t = 10
if 'Image' in bot_msg:
# Notify to ImageAgent
msg = Message(to=IMAGE_JID)
msg.set_metadata("performative", "request")
msg.body = bot_msg['Image']
await self.send(msg)
# Recive ImageAgent's response
response = await self.receive(timeout=3)
# Pass response to bot - notify to user
if response:
ingred = self.agent.INGREDIENTS[int(response.body)]
self.agent.pipe.send(ingred)
# else:
# self.agent.pipe.send('Lo siento, el servidor tiene problemas. Prueba más tarde')
elif 'CU-001' in bot_msg:
# Notify CheffAgent
msg = Message(to=CHEFF_JID)
msg.set_metadata("performative", "request")
msg.body = 'Start cooking!'
await self.send(msg)
# Recive cheff's response
response = await self.receive(timeout=t)
# Pass response to bot - notify to user
if response:
all_menus = np.array(json.loads(response.body))
if all_menus.max() > 0:
# # JSON with best recipe
# menu = {
# 'Title': self.recipe_book[all_menus.argmax()]['Title'],
# 'Ingredients': self.recipe_book[all_menus.argmax()]['Ingredients'],
# 'Directions': self.recipe_book[all_menus.argmax()]['Steps'],
# }
# List with 5 best recipes
menu = []
N = 5
best_menu = all_menus.argsort()[-N:][::-1]
for m in best_menu:
if all_menus[m] > 0:
menu.append(self.recipe_book[m]['Title'])
else:
break
else:
menu = None
self.agent.pipe.send(menu)
else:
self.agent.pipe.send(
'Lo siento, el servidor tiene problemas. Prueba más tarde'
)
elif 'CU-002' in bot_msg:
# Notify cheff
msg = Message(to=CHEFF_JID)
msg.set_metadata("performative", "query_ref")
msg.body = str(self.agent.RECIPES.index(bot_msg['CU-002']))
logger.info(
f"[DispatcherBehav] {bot_msg['CU-002']} - {msg.body}")
await self.send(msg)
# Recive cheff's response
response = await self.receive(timeout=t)
# Pass response to bot - notify to user
if response:
lst = json.loads(response.body)
self.agent.pipe.send(lst)
else:
self.agent.pipe.send(
'Lo siento, el servidor tiene problemas. Prueba más tarde'
)
elif 'CU-003' in bot_msg:
prefs = bot_msg['CU-003']
f = bot_msg['factor']
logger.info(
f'[DispatcherBehav] Message containing {len(prefs)} preferences'
)
logger.info(f'[DispatcherBehav] Factor of prefs is {f}')
msg = Message(to=CHEFF_JID)
msg.set_metadata("performative", "inform_ref")
v = -10 if f == 'GuardarAlergia' else 5
msgs = []
for i in prefs:
logger.info(i)
msgs.append({
'Ingredient':
self.agent.INGREDIENTS.index(i),
'Value':
v
})
msg.body = json.dumps(msgs)
await self.send(msg)
logger.info(f"[DispatcherBehav] Message sent: {msg.body}")
elif 'CU-004' in bot_msg:
choice = self.agent.RECIPES.index(bot_msg['CU-004'])
menu = {
'Title': self.recipe_book[choice]['Title'],
'Ingredients': self.recipe_book[choice]['Ingredients'],
'Directions': self.recipe_book[choice]['Steps'],
}
self.agent.pipe.send(menu)
else: # bad message
logger.warning(
f'[DispatcherBehav] Message recived: {bot_msg}')
def test_body_set_string():
msg = Message()
msg.body = "body"
def prepare_outdoor_temperature_request(receivers, date):
msg = Message(to=receivers)
msg.set_metadata('performative', 'request')
msg.set_metadata('type', 'outdoor_temperature_request')
msg.body = json.dumps({'date': time_to_str(date)})
return msg
def test_body_set_none():
msg = Message()
msg.body = None
def prepare_job_late_inform(self, date, receivers):
msg = Message(to=receivers)
msg.set_metadata('performative', 'inform')
msg.set_metadata('type', 'job_late_inform')
msg.body = json.dumps({'arrival_datetime': time_to_str(date)})
return msg
def prepare_room_data_inform(temperature, receivers):
msg = Message(to=receivers)
msg.set_metadata('performative', 'inform')
msg.set_metadata('type', 'room_data_inform')
msg.body = json.dumps({'temperature': temperature})
return msg
async def run(self):
global finish
msg = await self.receive(timeout=10
) # wait for a message for 10 seconds
if msg:
if msg.body is "ok":
print("Vendeur : Vendu pour {} euros !".format(
self.prix_courant))
finish = True
self.restart()
else:
if msg.body is "ko":
print("Vendeur : L'acheteur refuse, fin de la vente!")
finish = True
self.restart()
else:
print("Vendeur : Proposition reçu : {} euros".format(
msg.body))
prix_reçu = float(msg.body)
if prix_reçu >= self.prix_de_reserve_vendeur:
print("Vendeur : Vendu pour {} euros !".format(
prix_reçu))
msg = Message(to="buyer@localhost"
) # Instantiate the message
msg.set_metadata(
"performative",
"inform") # Set the "inform" FIPA performative
msg.body = "ok"
finish = True
self.restart()
else:
print("Vendeur : Prix proposé trop bas !")
msg = Message(to="buyer@localhost"
) # Instantiate the message
msg.set_metadata(
"performative",
"inform") # Set the "inform" FIPA performative
if self.prix_courant == self.prix_de_reserve_vendeur:
msg.body = "ko"
print(
"Vendeur : Je ne peux pas descendre plus bas que {} euros, je refuse la vente"
.format(self.prix_de_reserve_vendeur))
await self.send(msg)
finish = True
self.restart()
else:
self.prix_courant = float(
self.prix_courant *
self.concession_vendeur)
if self.prix_courant < self.prix_de_reserve_vendeur:
self.prix_courant = self.prix_de_reserve_vendeur
print(
"Vendeur : Envoie de la concession de {} euros"
.format(self.prix_courant))
msg.body = str(self.prix_courant)
await self.send(msg)
else:
print(
"Vendeur : Did not received any message after 10 seconds")
async def run(self):
msg = Message(to=str(self.recipient_jid))
msg.set_metadata("performative", "inform")
msg.body = self.message_body
await self.send(msg)
template = Template()
# template.sender = "sender1@host"
template.sender = "madks@Temp3rr0r-pc"
# template.to = "recv1@host"
template.to = "admin@Temp3rr0r-pc"
template.body = "Hello World"
template.thread = "thread-id"
template.metadata = {"performative": "query"}
message = Message()
# message.sender = "sender1@host"
message.sender = "madks@Temp3rr0r-pc"
# message.to = "recv1@host"
message.to = "admin@Temp3rr0r-pc"
message.body = "Hello World"
message.thread = "thread-id"
message.set_metadata("performative", "query")
assert template.match(message)
t1 = Template()
# t1.sender = "sender1@host"
t1.sender = "madks@Temp3rr0r-pc"
t2 = Template()
# t2.to = "recv1@host"
t2.to = "admin@Temp3rr0r-pc"
t2.metadata = {"performative": "query"}
m = Message()
# m.sender = "sender1@host"
def prepare_energy_usage_inform(energy, receivers):
msg = Message(to=receivers)
msg.set_metadata('performative', 'inform')
msg.set_metadata('type', 'energy_usage_inform')
msg.body = json.dumps({'energy_used_since_last_message': energy})
return msg
async def run(self):
msg = Message(to=self.m_Manager)
msg.set_metadata("performative", "inform")
msg.body = "ID: " + self.agent.name + " DESTROY "
await self.send(msg)
self.agent._kill()
def prepare_meeting_score_inform(receivers, guid, score):
msg = Message(to=receivers)
msg.set_metadata('performative', 'inform')
msg.set_metadata('type', 'meeting_score_inform')
msg.body = json.dumps({'meeting_guid': guid, 'score': score})
return msg
async def run(self):
# Cogemos la clasificacion, el presupuesto y las rachas de el equipo escogido
try:
clasificacion_equipo = self.clasificacion[self.equipo]['posicion']
except KeyError as error:
raise KeyError(f'No se puede obtener la clasificación del equipo {self.equipo}: {error}')
try:
if self.equipo in self.presupuestos.keys():
presupuesto_equipo = self.presupuestos[self.equipo]
else:
presupuesto_equipo = 0
except KeyError as error:
raise KeyError(f'No se puede obtener el presupuesto del equipo {self.equipo}: {error}')
try:
if self.equipo in self.rachas['ganando'].keys():
rachaG_equipo = self.rachas['ganando'][self.equipo]
else:
rachaG_equipo = 0
except KeyError as error:
raise KeyError(f'No se pueden obtener las rachas de partidos ganados por {self.equipo}: {error}')
try:
if self.equipo in self.rachas['perdiendo'].keys():
rachaP_equipo = self.rachas['perdiendo'][self.equipo]
else:
rachaP_equipo = 0
except KeyError as error:
raise KeyError(f'No se pueden obtener las rachas de partidos perdidos por {self.equipo}: {error}')
try:
if self.equipo in self.rachas['empatando'].keys():
rachaE_equipo = self.rachas['empatando'][self.equipo]
else:
rachaE_equipo = 0
except KeyError as error:
raise KeyError(f'No se pueden obtener las rachas de partidos empatados por {self.equipo}: {error}')
try:
if self.equipo in self.rachas['sin_ganar'].keys():
rachaNG_equipo = self.rachas['sin_ganar'][self.equipo]
else:
rachaNG_equipo = 0
except KeyError as error:
raise KeyError(f'No se pueden obtener las rachas de partidos empatados por {self.equipo}: {error}')
try:
if self.equipo in self.rachas['sin_perder'].keys():
rachaNP_equipo = self.rachas['sin_perder'][self.equipo]
else:
rachaNP_equipo = 0
except KeyError as error:
raise KeyError(f'No se pueden obtener las rachas de partidos empatados por {self.equipo}: {error}')
information = {
'clasificacion': clasificacion_equipo,
'presupuesto': presupuesto_equipo,
'rachas': {
'ganando': rachaG_equipo,
'empatando': rachaE_equipo,
'perdiendo': rachaP_equipo,
'sin_ganar': rachaNG_equipo,
'sin_perder': rachaNP_equipo
}
}
# Creamos el mensaje y lo mandamos al agente de reglas difusas
msg = Message(to="agente_reglas@localhost")
msg.set_metadata("performative", "inform") # Su performativa será de tipo inform
msg.body = json.dumps(information) # Convertimos el diccionario con la informacion del equipo en string
# Mandamos el mensaje
await self.send(msg)
# Detenemos el agente
await self.agent.stop()
