def getReplyStateForTargetIDAndMarkerType(self, targetID, targetMarkerType):
if targetMarkerType in self._chatCommands and targetID in self._chatCommands[targetMarkerType]:
commands = self._chatCommands[targetMarkerType][targetID]
for commandID, commandData in ((k, commands[k]) for k in reversed(commands)):
commandName = _ACTIONS.battleChatCommandFromActionID(commandID).name
if commandName not in BATTLE_CHAT_COMMANDS_BY_NAMES:
continue
hasRepliedTo = avatar_getter.getPlayerVehicleID() in commandData.owners
if hasRepliedTo:
return (ReplyState.CAN_CANCEL_REPLY, commandName)
if commandName in ONE_SHOT_COMMANDS_TO_REPLIES.keys():
return (ReplyState.CAN_CONFIRM, commandName)
return (ReplyState.CAN_REPLY, commandName)
playerVehicleID = avatar_getter.getPlayerVehicleID()
if playerVehicleID in self._chatCommands[targetMarkerType]:
commands = self._chatCommands[targetMarkerType][playerVehicleID]
for commandID, commandData in ((k, commands[k]) for k in reversed(commands)):
if targetID in commandData.owners and self.__delayer.hasDelayedCallbackID(commandData.callbackID):
commandName = _ACTIONS.battleChatCommandFromActionID(commandID).name
if commandName not in BATTLE_CHAT_COMMANDS_BY_NAMES:
continue
if commandName in ONE_SHOT_COMMANDS_TO_REPLIES.keys():
return (ReplyState.CAN_CONFIRM, commandName)
if commandName in COMMAND_RESPONDING_MAPPING.keys():
return (ReplyState.CAN_RESPOND, commandName)
return (ReplyState.NO_REPLY, None)
def __checkTemporarySticky(self, commandID, targetID):
if commandID not in self.__temporaryStickyCommands or targetID not in self.__temporaryStickyCommands[commandID]:
return
commandTargetID, markerType = self.__temporaryStickyCommands[commandID].pop(targetID)
isOneShot = _ACTIONS.battleChatCommandFromActionID(commandID).name in ONE_SHOT_COMMANDS_TO_REPLIES.keys()
focusedTargetID = 0
focusedMarkerType = ''
if self.__markerInFocus and self.__markerInFocus.isFocused(commandTargetID, markerType):
focusedTargetID = self.__markerInFocus.targetID
focusedMarkerType = self.__markerInFocus.markerType
fbCtrl = self.sessionProvider.shared.feedback
if fbCtrl and not (focusedMarkerType == markerType and commandTargetID == focusedTargetID):
fbCtrl.setInFocusForPlayer(commandTargetID, markerType, -1, MarkerType.INVALID_MARKER_TYPE, isOneShot)
if not self.__temporaryStickyCommands[commandID]:
self.__temporaryStickyCommands.pop(commandID)
def __onCommandReceivedReply(self, commandName, cmd):
replyToActionName = cmd.getCommandData()['strArg1']
if replyToActionName not in ONE_SHOT_COMMANDS_TO_REPLIES.keys():
return
elif replyToActionName in self.__customSoundHandlerReply:
self.__customSoundHandlerReply[replyToActionName](replyToActionName, cmd)
return
else:
if cmd.hasTarget():
if not cmd.isSender() and not cmd.isReceiver():
return
repliedToActionID = BATTLE_CHAT_COMMANDS_BY_NAMES[replyToActionName].id
notificationReply = _ACTIONS.battleChatCommandFromActionID(repliedToActionID).soundNotificationReply
if notificationReply is None:
_logger.warning('notificationReply is None for replyToActionName = %s !- Take a look at messenger_common_chat2.py', replyToActionName)
return
self.__playSoundNotificationOnCommandReceived(cmd, MarkerType.VEHICLE_MARKER_TYPE, True, notificationReply)
return
def __onCommandReceived(self, cmd):
if cmd.getCommandType() != MESSENGER_COMMAND_TYPE.BATTLE:
return
else:
controller = MessengerEntry.g_instance.gui.channelsCtrl.getController(cmd.getClientID())
if controller is None:
_logger.error('Controller not found %s', cmd)
return
if not controller.filterMessage(cmd):
return
commandName = _ACTIONS.battleChatCommandFromActionID(cmd.getID()).name
if commandName in _COMMAND_NAME_TRANSFORM_MARKER_TYPE or commandName in ONE_SHOT_COMMANDS_TO_REPLIES.keys():
self.__handleRegularCommand(cmd)
elif cmd.isReply():
self.__handleReply(cmd)
elif cmd.isCancelReply():
self.__handleCancelReply(cmd)
elif cmd.isClearChatCommand():
self.__handleClearChatCommands(cmd)
return
def __addCommandToList(self, commandID, commandName, commandCreatorID, commandTargetID, command, activeTime=_DEFAULT_ACTIVE_COMMAND_TIME):
markerType = _COMMAND_NAME_TRANSFORM_MARKER_TYPE[commandName]
if markerType not in self._chatCommands:
self._chatCommands[markerType] = dict()
owners = []
uniqueCBID = None
if not command.isServerCommand():
self.__tryRemovalOfPreviousLocationCommands(commandCreatorID)
if commandName in AUTOCOMMIT_COMMAND_NAMES:
self.__removeReplyContributionFromPlayer(commandCreatorID, markerType, commandTargetID)
uniqueCBID = self.__getUniqueCallbackID()
self.__delayer.delayCallback(uniqueCBID, activeTime, self.__removeCommandMarkerCB, commandID, commandTargetID)
if commandName in AUTOCOMMIT_COMMAND_NAMES:
owners.append(commandCreatorID)
if commandTargetID not in self._chatCommands[markerType]:
self._chatCommands[markerType][commandTargetID] = OrderedDict()
self._chatCommands[markerType][commandTargetID].update({commandID: AdvancedChatCommandData(command=command, commandCreatorVehID=commandCreatorID, callbackID=uniqueCBID, owners=owners)})
if self.sessionProvider.shared.feedback:
self.sessionProvider.shared.feedback.onCommandAdded(commandTargetID, markerType)
updateCmdType = ChatCommandChange.CHAT_CMD_WAS_REPLIED if commandName in AUTOCOMMIT_COMMAND_NAMES else ChatCommandChange.CHAT_CMD_TRIGGERED
self.__chatCommandsUpdated(markerType, commandTargetID, commandID, commandCreatorID, updateCmdType)
isTemporarySticky = command and not command.isInSilentMode() and command.isTemporarySticky() and not commandCreatorID == avatar_getter.getPlayerVehicleID()
if isTemporarySticky:
self.__temporaryStickyCommands[commandID][commandTargetID] = (commandTargetID, markerType)
if commandCreatorID == avatar_getter.getPlayerVehicleID() and commandName in AUTOCOMMIT_COMMAND_NAMES or isTemporarySticky:
BigWorld.callback(0.1, partial(self.__setInFocusCB, commandID, commandTargetID, markerType, commandName in ONE_SHOT_COMMANDS_TO_REPLIES.keys(), isTemporarySticky))
return
def onAction(self, action):
chatCommands = self.sessionProvider.shared.chatCommands
if chatCommands is None:
return
elif action == RADIAL_MENU_CONSTS.EMPTY_BUTTON_STATE or self.__crosshairData is None:
self.__setVisibility(False)
return
else:
if action == BATTLE_CHAT_COMMAND_NAMES.REPLY:
if self.__crosshairData.replyState == ReplyState.CAN_CONFIRM and self.__crosshairData.replyToAction in ONE_SHOT_COMMANDS_TO_REPLIES.keys(
):
chatCommands.handleChatCommand(
ONE_SHOT_COMMANDS_TO_REPLIES[
self.__crosshairData.replyToAction],
targetID=self.__crosshairData.targetID)
else:
chatCommands.sendReplyChatCommand(
self.__crosshairData.targetID,
self.__crosshairData.replyToAction)
elif action == BATTLE_CHAT_COMMAND_NAMES.CANCEL_REPLY:
chatCommands.sendCancelReplyChatCommand(
self.__crosshairData.targetID,
self.__crosshairData.replyToAction)
elif action in (BATTLE_CHAT_COMMAND_NAMES.GOING_THERE,
BATTLE_CHAT_COMMAND_NAMES.ATTENTION_TO_POSITION,
BATTLE_CHAT_COMMAND_NAMES.SPG_AIM_AREA):
chatCommands.sendAdvancedPositionPing(action,
isInRadialMenu=True)
else:
chatCommands.handleChatCommand(
action,
targetID=self.__crosshairData.targetID,
isInRadialMenu=True)
self.__crosshairData = None
self.__setVisibility(False)
return
def handleContexChatCommand(self, key):
cmdMap = CommandMapping.g_instance
advChatCmp = getattr(
self.sessionProvider.arenaVisitor.getComponentSystem(),
'advancedChatComponent', None)
if advChatCmp is None:
return
else:
for chatCmd, keyboardCmd in KB_MAPPING.iteritems():
if cmdMap.isFired(keyboardCmd, key):
if chatCmd in DIRECT_ACTION_BATTLE_CHAT_COMMANDS:
self.handleChatCommand(chatCmd)
return
targetID, targetMarkerType, markerSubType, replyState, replyToAction = self.getAimedAtTargetData(
)
if chatCmd in (BATTLE_CHAT_COMMAND_NAMES.THANKS,
BATTLE_CHAT_COMMAND_NAMES.TURNBACK):
replyState = ReplyState.NO_REPLY
if replyState == ReplyState.NO_REPLY:
if chatCmd in TARGET_TYPE_TRANSLATION_MAPPING and targetMarkerType in TARGET_TYPE_TRANSLATION_MAPPING[
chatCmd] and markerSubType in TARGET_TYPE_TRANSLATION_MAPPING[
chatCmd][targetMarkerType]:
action = TARGET_TYPE_TRANSLATION_MAPPING[chatCmd][
targetMarkerType][markerSubType]
else:
_logger.debug(
'Action %s (at key %s) is not supported for target type %s (cut type: %s)',
chatCmd, key, targetMarkerType, markerSubType)
return
if action == BATTLE_CHAT_COMMAND_NAMES.HELPME:
if advChatCmp.isTargetAllyCommittedToMe(targetID):
action = BATTLE_CHAT_COMMAND_NAMES.THANKS
self.handleChatCommand(action, targetID=targetID)
else:
if chatCmd == CONTEXTCOMMAND2 and replyState != ReplyState.CAN_REPLY:
return
if replyState == ReplyState.CAN_CANCEL_REPLY:
self.sendCancelReplyChatCommand(
targetID, replyToAction)
elif replyState == ReplyState.CAN_REPLY:
if replyToAction in (
BATTLE_CHAT_COMMAND_NAMES.HELPME,
BATTLE_CHAT_COMMAND_NAMES.SOS):
self.handleChatCommand(
BATTLE_CHAT_COMMAND_NAMES.SUPPORTING_ALLY,
targetID=targetID)
else:
self.sendReplyChatCommand(
targetID, replyToAction)
elif replyState == ReplyState.CAN_CONFIRM and replyToAction in ONE_SHOT_COMMANDS_TO_REPLIES.keys(
):
self.handleChatCommand(
ONE_SHOT_COMMANDS_TO_REPLIES[replyToAction],
targetID=targetID)
elif replyState == ReplyState.CAN_RESPOND and replyToAction in COMMAND_RESPONDING_MAPPING.keys(
):
self.handleChatCommand(
COMMAND_RESPONDING_MAPPING[replyToAction],
targetID=targetID)
return
