def handleCalloutAndRadialMenuKeyPress(self, key, isDown):
cmdMap = CommandMapping.g_instance
isRadialMenuKey = cmdMap.isFired(
CommandMapping.CMD_RADIAL_MENU_SHOW, key) or cmdMap.isFired(
CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND, key)
if not isRadialMenuKey:
return False
else:
containerManager = self.__appLoader.getApp().containerManager
if not containerManager.isContainerShown(WindowLayer.VIEW):
return False
if containerManager.isModalViewsIsExists(
) or self.__appLoader.getApp().hasGuiControlModeConsumers(
*_CONSUMERS_LOCKS):
return False
isPlayerObserver = self.sessionProvider.getCtx().isPlayerObserver()
if self.__radialKeyDown is None and isDown:
self.__radialKeyDown = key
if not self.hasDelayedCallback(
self.__openRadialMenu
) and avatar_getter.isVehicleAlive() and not isPlayerObserver:
self.__setAimingEnabled(isEnabled=False)
if self.__commandReceivedData is None and cmdMap.isFired(
CommandMapping.CMD_RADIAL_MENU_SHOW, key):
self.__openRadialMenu()
else:
self.delayCallback(_DELAY_FOR_OPENING_RADIAL_MENU,
self.__openRadialMenu)
return True
if self.__radialKeyDown is not None and not isDown:
if not self.__radialMenuIsOpen:
if cmdMap.isFired(
CommandMapping.CMD_CHAT_SHORTCUT_CONTEXT_COMMAND,
key
) and not avatar_getter.getForcedGuiControlModeFlags(
) & GUI_CTRL_MODE_FLAG.CURSOR_VISIBLE:
self.sessionProvider.handleContexChatCommand(key)
elif cmdMap.isFired(CommandMapping.CMD_RADIAL_MENU_SHOW,
key) and not isPlayerObserver:
gui_event_dispatcher.setRespondToCalloutCmd(
self.__radialKeyDown, isDown)
self.__resetRadialMenuData()
return True
if self.__radialKeyDown == key:
if self.__radialMenuIsOpen and avatar_getter.isVehicleAlive(
) and not isPlayerObserver:
gui_event_dispatcher.setRadialMenuCmd(key, False)
self.__resetRadialMenuData()
return True
return False
def __updateUpgrades(self):
upgrades = self.__getUpgradeItems()
self.__upgrades = []
if upgrades:
hasTwoModules = len(upgrades) == 2
if hasTwoModules:
self.__upgrades = [ upgrade.intCD for upgrade in upgrades ]
first = upgrades[0]
second = upgrades[1]
if isItemVehicleHull(first.intCD, self._getVehicle()):
titleKey = R.strings.battle_royale.upgradePanel.title.hull
else:
titleKey = R.strings.battle_royale.upgradePanel.title.dyn(first.itemTypeName, None)
if titleKey is None:
titleKey = R.strings.battle_royale.upgradePanel.title.default
data = {'firstItem': self.__getModuleInfo(first, 0),
'secondItem': self.__getModuleInfo(second, 1),
'title': backport.text(titleKey())}
if not self.__textInited:
key = br_helpers.getHotKeyString(CommandMapping.CMD_UPGRADE_PANEL_SHOW)
data['description'] = backport.text(R.strings.battle_royale.upgradePanel.description(), key=key)
data['isInitData'] = True
self.__textInited = True
self.as_setDataS(data)
self.__updateVisibility(hasTwoModules and avatar_getter.isVehicleAlive())
else:
logger.warning('Unexpected modules count. Modules list: %s', str(upgrades))
else:
self.__updateVisibility(False)
return
def __openRadialMenu(self):
self.__radialMenuIsOpen = True
if avatar_getter.isVehicleAlive(
) and not self.sessionProvider.getCtx().isPlayerObserver():
self.__executeHide()
gui_event_dispatcher.setRadialMenuCmd(self.__radialKeyDown,
self.__radialMenuIsOpen)
def __onVehicleStateUpdated(self, state, value):
if state in (VEHICLE_VIEW_STATE.DESTROYED, VEHICLE_VIEW_STATE.CREW_DEACTIVATED):
for marker in self._markers.values():
if marker.getIsPlayerTeam() or marker.getIsActionMarkerActive():
self._setMarkerBoundEnabled(marker.getMarkerID(), False)
elif state in (VEHICLE_VIEW_STATE.SWITCHING, VEHICLE_VIEW_STATE.RESPAWNING):
if not self.sessionProvider.getCtx().isPlayerObserver() and avatar_getter.isVehicleAlive():
for marker in self._markers.values():
if marker.isAlive():
self._setMarkerBoundEnabled(marker.getMarkerID(), True)
elif state == VEHICLE_VIEW_STATE.DEBUFF:
vehicle = BigWorld.player().getVehicleAttached()
if vehicle is not None:
vehicleID = vehicle.id
if vehicleID in self._markers:
self.__updateDebuffMarker(vehicleID, self._markers[vehicleID].getMarkerID(), value)
elif state == VEHICLE_VIEW_STATE.STEALTH_RADAR:
vehicle = BigWorld.player().getVehicleAttached()
if vehicle is not None:
vehicleID = vehicle.id
if vehicleID in self._markers:
self.__updateStealthRadarMarker(vehicleID, self._markers[vehicleID].getMarkerID(), value)
return
def __stopActionMarker(self, markerID, vehicleID):
self.__removeMarkerCallback(markerID)
self._invokeMarker(markerID, 'stopActionMarker')
marker = self._markers[vehicleID]
marker.setIsActionMarkerActive(False)
if marker and not avatar_getter.isVehicleAlive() and not marker.getIsPlayerTeam():
self._setMarkerBoundEnabled(marker.getMarkerID(), True)
def onCustomAction(cmd, target):
if not cmd.checkCooldown() or not (cmd.inPostmortem or avatar_getter.isVehicleAlive()):
return
player = BigWorld.player()
if target is None:
target = BigWorld.entities.get(player.playerVehicleID)
if cmd.channel == 'All' and player.arena.bonusType == ARENA_BONUS_TYPE.TRAINING:
chanId = 0
elif cmd.channel in ('Team', 'All'):
chanId = 1
else:
chanId = 2
targetInfo = player.arena.vehicles.get(target.id, {})
targetDict = {'name': target.publicInfo.name,
'vehicle': targetInfo['vehicleType'].type.shortUserString,
'clan': targetInfo['clanAbbrev']}
msg = cmd.format(targetDict)
if cmd.builtinCmd:
chatCommands = g_sessionProvider.shared.chatCommands
if chatCommands is not None:
chatCommands.handleChatCommand(cmd.builtinCmd, target.id)
BigWorld.callback(_config.data['chatDelay'] / 1000.0,
partial(sendChatMessage, msg.decode('utf-8'), chanId, _config.data['chatDelay']))
else:
sendChatMessage(msg.decode('utf-8'), chanId, _config.data['chatDelay'])
cmd.updateCooldown()
def sendTargetedCommand(self, cmdName, targetID):
if not avatar_getter.isVehicleAlive():
return
command = self.proto.battleCmd.createByNameTarget(cmdName, targetID)
if command:
self.__sendChatCommand(command)
else:
LOG_ERROR('Targeted command is not found or targetID is not defined', cmdName)
def sendTargetedCommand(self, cmdName, targetID):
if not avatar_getter.isVehicleAlive():
return
command = self.proto.battleCmd.createByNameTarget(cmdName, targetID)
if command:
self.__sendChatCommand(command)
else:
LOG_ERROR('Targeted command is not found or targetID is not defined', cmdName)
def sendCommand(self, cmdName):
if not avatar_getter.isVehicleAlive():
return
command = self.proto.battleCmd.createByName(cmdName)
if command:
self.__sendChatCommand(command)
else:
LOG_ERROR('Command is not found', cmdName)
def _canActivate(self, entityName=None, avatar=None):
vehicle = BigWorld.entities.get(avatar_getter.getPlayerVehicleID())
isAlive = avatar_getter.isVehicleAlive()
return (
True,
None) if vehicle and isAlive and self.__hasDebuffComponentsForStop(
vehicle) else super(_RepairBattleRoyaleCrewAndModules,
self)._canActivate(entityName, avatar)
def changeSetting(self, intCD, entityName = None, avatar = None):
if not avatar_getter.isVehicleAlive(avatar):
return (False, None)
result, error = False, None
item = self.getEquipment(intCD)
if item:
result, error = self.__doChangeSetting(item, entityName, avatar)
return (result, error)
def sendCommand(self, cmdName):
if not avatar_getter.isVehicleAlive():
return
command = self.proto.battleCmd.createByName(cmdName)
if command:
self.__sendChatCommand(command)
else:
LOG_ERROR('Command is not found', cmdName)
def _updateVehicleInfo(self):
if self.__isInRespawn:
return
self._deathAlreadySet = False
if self._isPlayerVehicle and not avatar_getter.isVehicleAlive():
self._showOwnDeathInfo()
else:
self._showPlayerInfo()
def onMessagePlaybackStarted(self, messageID, data):
componentSystem = self._sessionProvider.arenaVisitor.getComponentSystem(
)
notificationID = self._notificationMap[messageID]
isAttacker = avatar_getter.getPlayerTeam(
) == EPIC_BATTLE_TEAM_ID.TEAM_ATTACKER
if notificationID == EPIC_NOTIFICATION.RETREAT:
if not isAttacker:
if avatar_getter.isVehicleAlive():
EPIC_SOUND.PLAY_MSG_RETREAT_SUCCESSFUL = True
return
elif notificationID == EPIC_NOTIFICATION.HQ_DESTROYED:
bfVoMessage = self.__selectSoundNotifObjDestroy(
componentSystem, messageID, data['id'])
adType = EPIC_SOUND.BF_EB_HQ_DESTROYED_ATK_OR_DEF.get(
messageID, None)
if adType is None:
return
if self.__soundNotificationOnlyOneLeft:
objectiveId = '_' + str(data['id'])
soundNotification = BF_EB_MAIN_OBJECTIVES_SOUND_NOTIFICATIONS.ONE_DESTROYED + objectiveId + adType
if soundNotification is not None:
self.__playSound(soundNotification)
bfVoMessage += adType
self.__playSound(bfVoMessage)
return
else:
bfVoMessage = EPIC_SOUND.BF_EB_VO_MESSAGES.get(messageID, None)
if bfVoMessage is None:
return
if notificationID == EPIC_NOTIFICATION.HQ_UNDER_ATTACK:
sectorBaseId = data['id']
bfVoMessage = bfVoMessage.get(sectorBaseId, None)
elif notificationID == EPIC_NOTIFICATION.ZONE_CONTESTED:
sectorBaseName = self._getBaseNameByBaseId(data['id'])
bfVoMessage = bfVoMessage.get(sectorBaseName, None)
elif notificationID == EPIC_NOTIFICATION.ZONE_CAPTURED:
isPlayerLane = self._isPlayerLaneByBaseId(
componentSystem, data['id'])
bfVoMessage = bfVoMessage.get(isPlayerLane, None)
sectorBaseName = self._getBaseNameByBaseId(data['id'])
bfVoMessage += '_' + sectorBaseName
elif notificationID == EPIC_NOTIFICATION.OVERTIME:
self.__playSound(
EPIC_OVERTIME_SOUND_NOTIFICATIONS.BF_EB_OVERTIME_START)
if self.__playMsgRetreatSoundSuccessfull:
return
self.__playMsgRetreatSoundSuccessfull = True
bfVoMessage = bfVoMessage.get(isAttacker, None)
elif notificationID in {EPIC_NOTIFICATION.HQ_BATTLE_START}:
if self.__playMsgRetreatSoundSuccessfull:
return
self.__playMsgRetreatSoundSuccessfull = True
if messageID == GAME_MESSAGES_CONSTS.OVERTIME:
if data['id'] in OVERTIME_DURATION_WARNINGS:
return
self.__playSound(bfVoMessage)
return
def __onVehicleInFocus(self, vehicleID, isInFocus):
markerID = -1
if vehicleID > 0:
focusedMarker = self._markers.get(vehicleID)
if focusedMarker and focusedMarker.isAlive():
isVehicleValid = avatar_getter.isVehicleAlive() or not focusedMarker.getIsPlayerTeam() and not focusedMarker.getIsActionMarkerActive()
if isVehicleValid:
markerID = focusedMarker.getMarkerID()
self._setMarkerObjectInFocus(markerID, isInFocus)
def __onMinimapFeedbackReceived(self, eventID, entityID, value):
if eventID == FEEDBACK_EVENT_ID.MINIMAP_SHOW_MARKER and entityID != self.__playerVehicleID:
if entityID in self._entries:
entry = self._entries[entityID]
if (self.__isObserver or not avatar_getter.isVehicleAlive()
) and avatar_getter.getVehicleIDAttached() == entityID:
return
entry.isInAoI() and self._invoke(entry.getID(), 'setAnimation',
value)
def changeSetting(self, intCD, avatar=None):
if not avatar_getter.isVehicleAlive(avatar):
return False
else:
code = self.getNextSettingCode(intCD)
if code is None:
return False
avatar_getter.updateVehicleSetting(code, intCD, avatar)
avatar_getter.changeVehicleSetting(code, intCD, avatar)
return True
def changeSettingByTag(self, tag, entityName = None, avatar = None):
if not avatar_getter.isVehicleAlive(avatar):
return (False, None)
result, error = True, None
for intCD, item in self.__equipments.iteritems():
if item.getTag() == tag and item.getQuantity() > 0:
result, error = self.__doChangeSetting(item, entityName, avatar)
break
return (result, error)
def __resetRadialMenuData(self):
isPlayerObserver = self.sessionProvider.getCtx().isPlayerObserver()
if self.__radialKeyDown is not None and avatar_getter.isVehicleAlive(
) and not isPlayerObserver:
self.__radialMenuIsOpen = False
self.__radialKeyDown = None
if self.hasDelayedCallback(self.__openRadialMenu):
self.stopCallback(self.__openRadialMenu)
self.__setAimingEnabled(isEnabled=True)
return
def changeSetting(self, intCD, avatar = None):
if not avatar_getter.isVehicleAlive(avatar):
return False
code = self.getNextSettingCode(intCD)
if code is None:
return False
avatar_getter.updateVehicleSetting(code, intCD, avatar)
if avatar_getter.isPlayerOnArena(avatar):
avatar_getter.changeVehicleSetting(code, intCD, avatar)
return True
def sendTargetedCommand(self, cmdName, targetID):
if not avatar_getter.isVehicleAlive():
return
if not self.__cmdFactories:
LOG_ERROR('Commands factory is not defined')
return
command = self.__cmdFactories.createByNameTarget(cmdName, targetID)
if command:
self.__sendChatCommand(command)
else:
LOG_ERROR('Targeted command is not found or targetID is not defined', cmdName)
def sendEpicGlobalCommand(self, cmdName, baseName=''):
if not avatar_getter.isVehicleAlive(
) and cmdName in PROHIBITED_IF_DEAD or self.sessionProvider.getCtx(
).isPlayerObserver(
) and cmdName in PROHIBITED_IF_SPECTATOR or self.__isEnabled is False:
return
command = self.proto.battleCmd.createByGlobalMsgName(cmdName, baseName)
if command:
self.__sendChatCommand(command)
else:
_logger.error('Command not found: %s', cmdName)
def sendCancelReplyChatCommand(self, targetID, action):
if not avatar_getter.isVehicleAlive():
return
player = BigWorld.player()
command = self.proto.battleCmd.createCancelReplyByName(
targetID, action, player.id)
if command:
self.__sendChatCommand(command)
else:
_logger.error('Cancel reply command not valid for command id: %d',
targetID)
def __onVehicleStateUpdated(self, state, value):
if state in (VEHICLE_VIEW_STATE.DESTROYED, VEHICLE_VIEW_STATE.CREW_DEACTIVATED):
for marker in self._markers.values():
if marker.getIsPlayerTeam() or marker.getIsActionMarkerActive():
self._setMarkerBoundEnabled(marker.getMarkerID(), False)
elif state in (VEHICLE_VIEW_STATE.SWITCHING, VEHICLE_VIEW_STATE.RESPAWNING):
if not self.sessionProvider.getCtx().isPlayerObserver() and avatar_getter.isVehicleAlive():
for marker in self._markers.values():
if marker.isAlive():
self._setMarkerBoundEnabled(marker.getMarkerID(), True)
def __onVehicleInFocus(self, vehicleID, entityInFocusData):
if entityInFocusData.entityTypeInFocus != ENTITY_IN_FOCUS_TYPE.VEHICLE:
return
markerID = -1
if vehicleID > 0:
focusedMarker = self._markers.get(vehicleID)
if focusedMarker and focusedMarker.isAlive():
isVehicleValid = avatar_getter.isVehicleAlive() or not focusedMarker.getIsPlayerTeam() and not focusedMarker.getIsActionMarkerActive()
if isVehicleValid:
markerID = focusedMarker.getMarkerID()
self._setMarkerObjectInFocus(markerID, entityInFocusData.isInFocus)
def sendTargetedCommand(self, cmdName, targetID):
if not avatar_getter.isVehicleAlive():
return
if cmdName == CHAT_COMMANDS.ATTACKENEMY:
command = self.proto.battleCmd.createSPGAimTargetCommand(targetID, self.__getReloadTime())
else:
command = self.proto.battleCmd.createByNameTarget(cmdName, targetID)
if command:
self.__sendChatCommand(command)
else:
LOG_ERROR('Targeted command is not found or targetID is not defined', cmdName)
def getExitResult(self):
if not self.__isReplayPlaying and not self.__arenaVisitor.gui.isTrainingBattle() and not self.__arenaVisitor.gui.isBattleRoyale() and not self.__arenaVisitor.gui.isMapsTraining():
vInfo = self.__arenaDP.getVehicleInfo()
vStats = self.__arenaDP.getVehicleStats()
if self.__arenaVisitor.hasRespawns():
isDeserter = not vStats.stopRespawn
else:
isDeserter = avatar_getter.isVehicleAlive() and not avatar_getter.isVehicleOverturned()
return BattleExitResult(isDeserter, vInfo.player)
else:
return BattleExitResult(False, None)
return None
def sendReplyChatCommand(self, targetID, action):
if not avatar_getter.isVehicleAlive() or self.sessionProvider.getCtx(
).isPlayerObserver() or self.__isEnabled is False:
return
player = BigWorld.player()
command = self.proto.battleCmd.createReplyByName(
targetID, action, player.id)
if command:
self.__sendChatCommand(command)
else:
_logger.error('Reply command not valid for command id: %d',
targetID)
def __onCameraChanged(self, mode, vehicleID=0):
if mode != CTRL_MODE_NAME.POSTMORTEM or vehicleID == 0:
self.__followingIgnoredTank = vehicleID
return
if self.__followingIgnoredTank > 0:
oldMarker = self._markers.get(self.__followingIgnoredTank)
if oldMarker and not (not avatar_getter.isVehicleAlive() and oldMarker.getIsPlayerTeam()):
self._setMarkerBoundEnabled(oldMarker.getMarkerID(), True)
if vehicleID > 0:
newMarker = self._markers.get(vehicleID)
if newMarker:
self._setMarkerBoundEnabled(newMarker.getMarkerID(), False)
self.__followingIgnoredTank = vehicleID
def sendCommandToBase(self, baseIdx, cmdName, baseName=''):
if not avatar_getter.isVehicleAlive(
) and cmdName in PROHIBITED_IF_DEAD or self.sessionProvider.getCtx(
).isPlayerObserver(
) and cmdName in PROHIBITED_IF_SPECTATOR or self.__isEnabled is False:
return
if self.sessionProvider.arenaVisitor.gui.isInEpicRange():
baseName = ID_TO_BASENAME[baseIdx]
command = self.proto.battleCmd.createByBaseIndexAndName(
baseIdx, cmdName, baseName)
if command:
self.__sendChatCommand(command)
else:
_logger.error('Command not found: %s', cmdName)
def getExitResult(self):
""" Gets result if player exits battle that are helped to notify player about penalty (if they have).
:return: instance of BattleExitResult(isDeserter, player).
"""
if not self.__isReplayPlaying and not self.__arenaVisitor.gui.isTrainingBattle() and not self.__arenaVisitor.gui.isEventBattle():
vInfo = self.__arenaDP.getVehicleInfo()
vStats = self.__arenaDP.getVehicleStats()
if self.__arenaVisitor.hasRespawns():
isDeserter = not vStats.stopRespawn
else:
isDeserter = avatar_getter.isVehicleAlive() and not avatar_getter.isVehicleOverturned()
return BattleExitResult(isDeserter, vInfo.player)
else:
return BattleExitResult(False, None)
return None
def __onStaticMarkerAdded(self,
areaID,
creatorID,
position,
locationMarkerSubtype,
show3DMarker=False,
markerText='',
numberOfReplies=0,
isTargetForPlayer=False):
if not show3DMarker or locationMarkerSubtype not in _LOCATION_SUBTYPE_TO_FLASH_SYMBOL_NAME:
return
if areaID in self._markers:
_logger.debug(
'__onStaticMarkerAdded should not be called 2 times with the same areaID'
)
return
markerID = self._createMarkerWithPosition(
_LOCATION_SUBTYPE_TO_FLASH_SYMBOL_NAME[locationMarkerSubtype],
position)
marker = self.__clazz(markerID, position, True, locationMarkerSubtype)
self._setMarkerRenderInfo(markerID, _STATIC_MARKER_MIN_SCALE,
_STATIC_MARKER_BOUNDS,
_INNER_STATIC_MARKER_BOUNDS,
_STATIC_MARKER_CULL_DISTANCE,
_STATIC_MARKER_BOUNDS_MIN_SCALE)
self._setMarkerLocationOffset(markerID, self._MIN_Y_OFFSET,
self._MAX_Y_OFFSET,
self._DISTANCE_FOR_MIN_Y_OFFSET)
self._markers[areaID] = marker
marker.setState(ReplyStateForMarker.CREATE_STATE)
if locationMarkerSubtype == LocationMarkerSubType.PREBATTLE_WAYPOINT_SUBTYPE:
currentPeriod = avatar_getter.getArena().period
if currentPeriod not in [
constants.ARENA_PERIOD.BATTLE,
constants.ARENA_PERIOD.AFTERBATTLE
]:
self._invokeMarker(markerID, 'alwaysShowCreatorName', True)
else:
self._invokeMarker(markerID, 'alwaysShowCreatorName', False)
if locationMarkerSubtype == LocationMarkerSubType.GOING_TO_MARKER_SUBTYPE:
marker.setIsSticky(isTargetForPlayer)
self._setMarkerRepliesAndCheckState(marker, 1, isTargetForPlayer)
else:
self._setActiveState(marker, ReplyStateForMarker.CREATE_STATE)
self._invokeMarker(markerID, 'setCreator', markerText)
if self.sessionProvider.getCtx().isPlayerObserver(
) or not avatar_getter.isVehicleAlive():
self._setMarkerBoundEnabled(marker.getMarkerID(), False)
def inj_hkKeyEvent(event):
BattleApp = g_appLoader.getDefBattleApp()
try:
if BattleApp and _config.data['enabled']:
if not (len(_config.data['hotkey']) == 1 and
BigWorld.player()._PlayerAvatar__forcedGuiCtrlModeFlags):
if avatar_getter.isVehicleAlive() and event.isKeyDown(
) and PYmodsCore.checkKeys(_config.data['hotkey']):
SoundLoop(True)
if _config.data['chatEnable']:
calltext()
else:
SoundLoop(False)
except StandardError:
print 'Horns: ERROR at inj_hkKeyEvent'
traceback.print_exc()
def getExitResult(self):
""" Gets result if player exits battle that are helped to notify player about penalty (if they have).
:return: instance of BattleExitResult(isDeserter, player).
"""
if not self.__isReplayPlaying and not self.__arenaVisitor.gui.isTrainingBattle():
vInfo = self.__arenaDP.getVehicleInfo()
vStats = self.__arenaDP.getVehicleStats()
if self.__arenaVisitor.gui.isEventBattle():
isDeserter = False
elif self.__arenaVisitor.hasRespawns():
isDeserter = not vStats.stopRespawn
else:
isDeserter = avatar_getter.isVehicleAlive() and not avatar_getter.isVehicleOverturned()
return BattleExitResult(isDeserter, vInfo.player)
else:
return BattleExitResult(False, None)
return None
def sendAttentionToPosition3D(self, position, name):
if not avatar_getter.isVehicleAlive(
) and name in PROHIBITED_IF_DEAD or self.sessionProvider.getCtx(
).isPlayerObserver(
) and name in PROHIBITED_IF_SPECTATOR or self.__isEnabled is False:
return
positionVec = Math.Vector3(position[0], position[1], position[2])
if name == BATTLE_CHAT_COMMAND_NAMES.SPG_AIM_AREA and self.__isSPG():
command = self.proto.battleCmd.createByPosition(
positionVec, name, self.__getReloadTime())
else:
command = self.proto.battleCmd.createByPosition(positionVec, name)
if command:
self.__sendChatCommand(command)
else:
_logger.error(
'Minimap command for position (%d, %d, %d) not found',
positionVec.x, positionVec.y, positionVec.z)
