def __cb_onGetItemsFromInventory(self, resultID, data):
self._gui.hideWaiting('request-tankman')
if resultID < RES_SUCCESS:
LOG_ERROR(
'Server return error inventory {0:d} items request, responseCode='
.format(_TANKMAN, resultID))
self.isRunning = False
return
self.toggle(
isOn=self.isOn(data.get('compDescr', {}).get(self.getVar())))
def isConditionOk(self, condition):
chapter = self._descriptor.getChapter(condition.getID())
if chapter is None:
LOG_ERROR('Chapter is not found', condition.getID())
return False
else:
result = chapter.isBonusReceived(self._bonuses.getCompleted())
if condition.isPositiveState():
return result
return not result
def _parseEffect(xmlCtx, section, flags, afterBattle = False):
function = _EFFECT_TAGS.get(section.name)
result = None
if 'after-battle-filter' in section.keys() and not afterBattle:
return result
if function is not None:
result = function(xmlCtx, section, flags, _parseConditions(xmlCtx, section, flags))
else:
LOG_ERROR('Effect is not supported:', section.name)
return result
def triggerEffect(self):
from gui.prb_control.context import PrebattleAction
from gui.prb_control.dispatcher import g_prbLoader
from gui.prb_control.settings import PREBATTLE_ACTION_NAME
dispatcher = g_prbLoader.getDispatcher()
if dispatcher is not None:
dispatcher.doSelectAction(PrebattleAction(PREBATTLE_ACTION_NAME.RANDOM_QUEUE))
else:
LOG_ERROR('Prebattle dispatcher is not defined')
return
def triggerEffect(self):
self._gui.release()
window = self.getTarget()
if window is not None:
content = window.getContent()
if not window.isContentFull():
query = self._tutorial._ctrlFactory.createContentQuery(
window.getType())
query.invoke(content, window.getVarRef())
self._setActions(window)
isRunning = self._gui.playEffect(
GUI_EFFECT_NAME.SHOW_WINDOW,
[window.getID(), window.getType(), content])
if not isRunning:
LOG_ERROR('Can not play effect "ShowWindow"', window.getID(),
window.getType())
else:
LOG_ERROR('PopUp not found', self._effect.getTargetID())
return
def stop(self, effectID=None):
isForceStop = effectID is None
if not isForceStop:
if effectID not in self._windowIDs:
LOG_ERROR('Window is not opened', effectID)
return
effectIDs = {effectID}
else:
effectIDs = self._windowIDs.copy()
container = self._getContainer(ViewTypes.WINDOW)
if container is not None:
getView = container.getView
for eID in effectIDs:
window = getView(criteria={POP_UP_CRITERIA.UNIQUE_NAME: eID})
if window is not None:
window.destroy()
self._windowIDs.remove(eID)
elif not isForceStop:
LOG_ERROR('Window is not opened', eID)
def makeCtx(cls, record):
result = cls._makeDefault()
if record is not None and len(record):
try:
result = cls._make(struct.unpack(BATTLE_RECORDS_FORMAT,
record))
except struct.error:
LOG_ERROR('Client ctx is not valid', record)
return result
def triggerEffect(self):
targetID = self._effect.getTargetID()
command = self._gui.config.getCommand(targetID)
if command is not None:
argOverrides = self._effect.getArgOverrides()
if argOverrides:
if isinstance(command.args, dict):
newArgs = command.args.copy()
newArgs.update(argOverrides)
command = command._replace(args=newArgs)
else:
LOG_ERROR(
'cannot override GUI command args by name: arg list was not defined as dict',
targetID)
self._gui.invokeCommand(command)
return True
else:
LOG_ERROR('Command not found', targetID)
return False
def triggerEffect(self):
command = self.getTarget()
if command is not None:
player = BigWorld.player()
attr = getattr(player, command.getName(), None)
if attr is not None and callable(attr):
try:
attr(*command.args(), **command.kwargs())
return True
except TypeError:
LOG_ERROR('Number of arguments mismatch',
command.getName(), command.args(),
command.kwargs())
else:
LOG_ERROR('Player has not method', command.getName())
else:
LOG_ERROR('Command not found', self._effect.getTargetID())
return False
def update(self):
super(FunctionalBattleScene, self).update()
if _MarkersStorage.hasMarkers():
tManager = TriggersManager.g_manager
if tManager is None or not tManager.isEnabled():
LOG_ERROR('TriggersManager is not defined or is not enabled')
return
_MarkersStorage.updateMarkers(tManager)
if self._arenaFinished and self.__isDelayPerformed():
_leaveArena()
def __getNextCheckpoint(self):
if self.__nextCheckpointIndex < len(self.__checkpointsSequence):
nextCheckpointID = self.__checkpointsSequence[
self.__nextCheckpointIndex]
checkpoint = self._data.getHasIDEntity(nextCheckpointID)
if checkpoint is None:
LOG_ERROR('checkpoint not found:', nextCheckpointID)
else:
return checkpoint
return
def __make4Area(self, typeID, triggerID, markers2D, minimap, data):
tManager = TriggersManager.g_manager
if tManager is None or not tManager.isEnabled():
LOG_ERROR('TriggersManager is not defined or is not enabled')
return
else:
position = tManager.getTriggerPosition(typeID, triggerID)
distance = tManager.getDistanceToTrigger(typeID, triggerID)
if position is None:
LOG_ERROR('Can not determine position of object', triggerID)
return
indicatorCtrl = None
if data.isIndicatorCreate():
indicator = self._gui.getDirectionIndicator()
if indicator is None:
LOG_ERROR('Directional indicator not found', triggerID)
else:
indicatorCtrl = _DirectionIndicatorCtrl(indicator, ('green', 'green'), position)
return _AreaMarker(typeID, triggerID, _StaticWorldMarker2D(triggerID, markers2D, data.getWorldData(), position, distance), _StaticMinimapMarker2D(data.getID(), minimap, position), _StaticObjectMarker3D(data.getModelData(), position), _StaticObjectMarker3D(data.getGroundData(), position), indicatorCtrl)
def __cb_onGetItemsFromInventory(self, resultID, data):
self._gui.hideWaiting('request-inventory-items')
if resultID < RES_SUCCESS:
LOG_ERROR(
'Server return error inventory vehicles request, responseCode = {0:d}'
.format(resultID))
self.isRunning = False
return
self._vehicles = len(data.get('compDescr', {}))
self.toggle(isOn=self.isOn())
def __cb_onSlotsReceived(self, resultID, slots):
self._gui.hideWaiting('request-slots')
if resultID < 0:
LOG_ERROR('Server return error credits request: ', resultID)
self.isRunning = False
return
self._slots = slots
self._gui.showWaiting('request-inventory-items')
BigWorld.player().inventory.getItems(_VEHICLE,
self.__cb_onGetItemsFromInventory)
def triggerEffect(self):
hint = self.getTarget()
if hint is not None:
self._gui.playEffect('ShowHint',
hint.getData(),
itemRef=hint.getTargetID(),
containerRef=hint.getContainerID())
else:
LOG_ERROR('Hint not found', self._effect.getTargetID())
return
def invoke(self, ui, cmdData):
ns, method = self._py_searchMethod(ui, cmdData)
if method is not None and callable(method):
try:
method(*cmdData.args[:])
except Exception:
LOG_CURRENT_EXCEPTION()
else:
LOG_ERROR('GUI method not found', ui, cmdData)
def triggerEffect(self):
setting = self.getTarget()
if setting is None:
LOG_ERROR('Tutorial setting is not found',
self._effect.getTargetID())
return False
else:
AccountSettings.setSettings(setting.getSettingName(),
setting.getSettingValue())
return True
def invoke(self, _, cmdData):
pathList = cmdData.name.split('.')
methodName = pathList.pop()
path = '.'.join(pathList)
imported = __import__(path, globals(), locals(), [methodName])
method = getattr(imported, methodName, None)
if method is not None and callable(method):
method(*cmdData.args[:])
else:
LOG_ERROR('GUI method not found', cmdData)
def showServiceMessage(self, data, msgTypeName):
msgType, messageID = (None, 0)
if msgTypeName is not None:
msgType = getattr(SCH_CLIENT_MSG_TYPE, msgTypeName, None)
if msgType is None:
LOG_ERROR('Message type not found', msgType)
if self.proto:
messageID = self.proto.serviceChannel.pushClientMessage(
data, msgType)
return messageID
def _readMarkerSection(xmlCtx, section, _):
markerID = sub_parsers.parseID(xmlCtx, section, 'Specify a marker ID')
type = _xml.readString(xmlCtx, section, 'type')
marker = None
if type in _MARKER_TYPES:
parser = _MARKER_TYPES[type]
marker = parser(xmlCtx, section, markerID, _xml.readString(xmlCtx, section, 'var-ref'))
else:
LOG_ERROR('Marker is not supported:', type)
return marker
def play(self, effectData):
effectData = effectData[0]
result = False
if 'type' in effectData and 'dialogID' in effectData:
dialogType = effectData['type']
dialogID = effectData['dialogID']
if dialogID == self._dialogID:
LOG_ERROR('Dialog is displayed', effectData['dialogID'])
return False
if dialogType in self._aliasMap:
alias = self._aliasMap[dialogType]
self._dialogID = dialogID
self._app.loadView(alias, dialogID, effectData)
result = True
else:
LOG_ERROR('Alias of dialog not found', effectData, self._aliasMap)
else:
LOG_ERROR('Type or id of dialog not found', effectData)
return result
def _readImageSection(xmlCtx, section, _):
imageID = sub_parsers.parseID(xmlCtx, section, 'Specify a image ID')
imageType = _xml.readString(xmlCtx, section, 'type')
image = None
if imageType in _IMAGE_TYPES:
parser = _IMAGE_TYPES[imageType]
image = parser(xmlCtx, section, imageID)
else:
LOG_ERROR('Image is not supported:', imageType)
return image
def _isConditionActive(self, condition):
condType = condition.getType()
functional = condType in _SUPPORTED_CONDITIONS and _SUPPORTED_CONDITIONS[
condType]
if not functional:
raise AssertionError('Function condition can not be empty')
else:
LOG_ERROR('Condition is not found', condType)
functional = FunctionalCondition()
return functional().isConditionOk(condition)
def __onComponentLost(self, event):
if not event.targetID:
LOG_ERROR(
'Key targetID is not defined in the event ON_COMPONENT_LOST')
return
itemID = event.targetID
for effect in self.effects.filterByName(GUI_EFFECT_NAME.SHOW_HINT):
effect.cancel(itemID)
self.onItemLost(itemID)
def isConditionOk(self, condition):
getter = game_vars.getItemStateGetter(condition.getBaseState())
if getter:
tvars = self._tutorial.getVars()
varID = condition.getID()
value = tvars.get(varID, default=varID)
otherID = condition.getOtherID()
other = tvars.get(otherID, default=otherID)
try:
result = getter(value, other)
except Exception as e:
LOG_ERROR('Can not resolve condition', varID, e.message)
return False
if condition.isPositiveState():
return result
return not result
LOG_ERROR('State of item can not be resolved', condition)
return False
def _readComplexCondition(xmlCtx, section, flags):
items = []
for name, subSection in section.items():
function = _conditions.tags.get(name)
if function is None:
LOG_ERROR('Condition is not supported: ', name)
continue
items.append(function(xmlCtx, subSection, flags))
return items
def __make4Vehicle(self, vehicleID, _, minimap, data):
if vehicleID is None:
LOG_ERROR('Vehicle not found', vehicleID)
return
else:
vehicle = BigWorld.entities.get(vehicleID)
if vehicle is None:
LOG_ERROR('Vehicle not found', vehicleID)
return
indicatorCtrl = None
if data.isIndicatorCreate():
indicator = self._gui._getDirectionIndicator()
if indicator is None:
LOG_ERROR('Directional indicator not found')
else:
indicatorCtrl = _DirectionIndicatorCtrl(
indicator, ('red', 'purple'), vehicle.position)
return _VehicleMarker(vehicleID, minimap, data.getPeriod(),
indicatorCtrl)
def __cb_onCreditsReceived(self, resultID, credits):
self._gui.hideWaiting('request-credits')
if resultID < 0:
LOG_ERROR('Server return error credits request: ', resultID)
self.isRunning = False
return
self._accCredits = credits
self._gui.showWaiting('request-shop')
itemTypeID, nationID, _ = vehicles.parseIntCompactDescr(self.getVar())
BigWorld.player().shop.getAllItems(self.__cb_onShopItemsReceived)
def _parseSimpleWindow(xmlCtx, section, flags):
windowID = parseID(xmlCtx, section, 'Specify a window ID')
windowType = _xml.readString(xmlCtx, section, 'type')
content = {}
parser = _WINDOW_SUB_PARERS.get(windowType)
if parser is not None:
window = parser(xmlCtx, section, flags, windowID, windowType, content)
else:
window = None
LOG_ERROR('Type of window is not supported: ', windowType)
return window
def triggerEffect(self):
self._gui.release()
dialog = self.getTarget()
if dialog is not None:
self._isRunning = True
if self._gui.isGuiDialogDisplayed():
self._isDialogClosed = True
return
content = dialog.getContent()
if not dialog.isContentFull():
query = self._tutorial._ctrlFactory.createContentQuery(
dialog.getType())
query.invoke(content, dialog.getVarRef())
self._isRunning = self._gui.playEffect(GUI_EFFECT_NAME.SHOW_DIALOG,
[content])
if not self._isRunning:
LOG_ERROR('Can not play effect "ShowDialog"', dialog.getID(),
dialog.getType())
else:
LOG_ERROR('Dialog not found', self._effect.getTargetID())
