def onInfluenceZoneSpawn(self, influenceZone, go):
from battle_royale.abilities.dynamic_cache_loader import DynamicObjectsCacheLoader
equipment = vehicles.g_cache.equipments()[influenceZone.equipmentID]
if not equipment.usagePrefab:
go.createComponent(DynamicObjectsCacheLoader, self.spaceID,
influenceZone.equipmentID,
influenceZone.zonesPosition, influenceZone.team)
return
def postloadSetup(go):
eqComponent = go.createComponent(InfluenceZoneEquipmentComponent)
eqComponent.setupEquipment(equipment)
multiVisualizer = go.findComponentByType(
InfluenceZoneMultiVisualizer)
if multiVisualizer is not None:
self.__multipositionSpawn(go, multiVisualizer, influenceZone,
equipment,
equipment.influenceZone.radius)
markerComponent = go.findComponentByType(CombatMarker)
if markerComponent is not None:
postfix = self.ENEMY_MARKER_POSTFIX
if self.__guiSessionProvider.getArenaDP().isAllyTeam(
influenceZone.team):
postfix = self.ALLY_MARKER_POSTFIX
markerComponent.shape += postfix
markerComponent.disappearanceRadius = equipment.radius + equipment.influenceZone.radius
terrainAreaComponent = go.findComponentByType(
InfluenceZoneTerrainArea)
if terrainAreaComponent is not None:
terrainAreaComponent.dropOffset = influenceZone.dropOffset
return
CGF.loadGameObjectIntoHierarchy(equipment.usagePrefab, go,
Math.Vector3(0, 0, 0), postloadSetup)
def tick(self):
if not self.__sequenceAnimator.isPlaying():
self.__sequenceAnimator.stop()
self.__sequenceAnimator.setEnabled(False)
self.__sequenceAnimator = None
CGF.removeGameObject(self.parent)
return
def onEnterWorld(self, prereqs):
super(ClientSelectableCGFObject, self).onEnterWorld(prereqs)
parent = self.entityGameObject
if parent is not None and self.usedPrefab:
CGF.loadGameObjectIntoHierarchy(self.usedPrefab, parent, Vector3(),
self.__onGameObjectLoaded)
return
def __launch(self, gameObject, thunderStrikeEntity, equipment):
def postloadSetup(go):
go.addComponent(equipment)
thunderStrikeEntity.onHit += functools.partial(self.__processHit, go)
CGF.loadGameObjectIntoHierarchy(equipment.usagePrefab, gameObject, Math.Vector3(0, 0, 0), postloadSetup)
def __processFlightEnd(self):
self.onFlightEnd(self)
if self.parent is not None:
self.parent.removeComponent(self.plane)
self.plane = None
if self.cargo is None:
CGF.removeGameObject(self.parent)
return
def wrapper(func):
CGF.registerManager(manager, False, presentInEditor)
def wrapper_self(self):
CGF.createManager(manager, func(self), self.spaceID)
return None
return ManagerRegistrator(wrapper_self)
def __assemblePrefabComponent(appearance, attachment, _, __):
def _onLoaded(gameObject):
appearance.undamagedStateChildren.append(gameObject)
gameObject.createComponent(GenericComponents.RedirectorComponent, appearance.gameObject)
gameObject.createComponent(GenericComponents.DynamicModelComponent, appearance.compoundModel)
CGF.loadGameObjectIntoHierarchy(attachment.modelName, appearance.gameObject, attachment.transform, _onLoaded)
def __launch(self, equipment, position, duration):
def postloadSetup(go):
go.addComponent(equipment)
go.createComponent(GenericComponents.RemoveGoDelayedComponent,
duration)
CGF.loadGameObject(equipment.usagePrefab, self.entity.spaceID,
position, postloadSetup)
def endShotPassion(self, vehicle):
def postloadSetup(go):
go.createComponent(GenericComponents.RedirectorComponent, vehicle.appearance.gameObject)
if vehicle is not None and vehicle.isAlive() and vehicle.appearance:
equipmentID = vehicles.g_cache.equipmentIDs().get(VehicleShotPassionComponent.EQUIPMENT_NAME)
equipment = vehicles.g_cache.equipments()[equipmentID]
CGF.loadGameObjectIntoHierarchy(equipment.posteffectPrefab, vehicle.appearance.partsGameObjects.getPartGameObject(TankNodeNames.GUN_INCLINATION, vehicle.appearance.gameObject.spaceID, vehicle.appearance.gameObject), Math.Vector3(0, 0, 0), postloadSetup)
return
def manager_registrator(cls):
CGF.registerManager(cls, presentInAllWorlds, presentInEditor,
creationPredicate)
modulePath = sys.modules[
cls.
__module__].__file__ if cls.__module__ != '__builtin__' else '__builtin__'
CGF.registerModulePath(cls, modulePath)
if presentInAllWorlds is False:
generateRule(cls, category)
return cls
def __clearModelAnimators(self):
self.flagComponent = None
for modelAnimator in self.__modelAnimators:
modelAnimator.animator.stop()
self.__modelAnimators = []
for go in self.undamagedStateChildren:
CGF.removeGameObject(go)
self.undamagedStateChildren = []
return
def loadAppearancePrefab(prefab, appearance, posloadCallback=None):
def _onLoaded(gameObject):
appearance.undamagedStateChildren.append(gameObject)
gameObject.createComponent(GenericComponents.RedirectorComponent, appearance.gameObject)
gameObject.createComponent(GenericComponents.DynamicModelComponent, appearance.compoundModel)
if posloadCallback:
posloadCallback(gameObject)
if appearance.compoundModel:
CGF.loadGameObjectIntoHierarchy(prefab, appearance.gameObject, Math.Vector3(0, 0, 0), _onLoaded)
else:
appearance.pushToLoadingQueue(prefab, appearance.gameObject, Math.Vector3(0, 0, 0), _onLoaded)
def __onResourceLoaded(self, effectP, position, scaleRatio, pointDescr,
resourceRefs):
if effectP in resourceRefs.failedIDs:
return
else:
gameObject = self.gameObject
if gameObject is None:
return
x = z = pointDescr.radius
if scaleRatio:
y = x / scaleRatio
zoneHeight = y * pointDescr.height / (pointDescr.height +
pointDescr.depth)
zoneDepth = y - zoneHeight
else:
zoneHeight = pointDescr.height
zoneDepth = pointDescr.depth
scale = (x, zoneHeight + zoneDepth, z)
from battleground.components import SequenceComponent
yShift = -zoneDepth
position = position + Math.Vector3(0, yShift, 0)
g = CGF.GameObject(self.spaceID)
g.createComponent(GenericComponents.TransformComponent, position)
g.createComponent(GenericComponents.HierarchyComponent,
self.gameObject)
sequenceComponent = g.createComponent(SequenceComponent,
resourceRefs[effectP])
sequenceComponent.createTerrainEffect(position,
scale=scale,
loopCount=-1)
g.activate()
g.transferOwnershipToWorld()
return
def _createParticles(self):
if self.__vehicleEffectConfig is not None:
self.__particle = gameObject = CGF.GameObject(self.__gameObject.spaceID)
gameObject.createComponent(GenericComponents.HierarchyComponent, self.__gameObject)
gameObject.createComponent(GenericComponents.ParticleComponent, self.__vehicleEffectConfig.path, True, self.__vehicleEffectConfig.rate)
gameObject.createComponent(GenericComponents.TransformComponent, self.__vehicleEffectConfig.offset)
gameObject.activate()
return
def __enableGroupDraw(self, enable, groupName):
highlightQuery = CGF.Query(self.spaceID,
(HighlightComponent, DynamicModelComponent))
for highlightComponent, dynamicModelComponent in highlightQuery:
if highlightComponent.groupName and highlightComponent.groupName == groupName:
if enable:
BigWorld.wgAddEdgeDetectDynamicModel(dynamicModelComponent)
else:
BigWorld.wgDelEdgeDetectDynamicModel(dynamicModelComponent)
class TestMaterialManipulatorManager(CGF.ComponentManager):
queryManipulator = CGF.QueryConfig(TestMaterialParamManipulator)
@tickGroup('Simulation')
def tick1(self):
for manipulator in self.queryManipulator:
manipulator.model().setMaterialParameterVector4(
manipulator.paramName,
Math.Vector4(0, math.sin(self.clock.gameTime), 1, 0))
def __init__(self, arenaUniqueID, arenaTypeID, arenaBonusType, arenaGuiType, arenaExtraData, spaceID):
self.__vehicles = {}
self.__vehicleIndexToId = {}
self.__positions = {}
self.__statistics = {}
self.__teamBasesData = defaultdict(dict)
self.__periodInfo = (ARENA_PERIOD.WAITING,
0,
0,
None)
self.__viewPoints = []
self.__isFogOfWarEnabled = False
self.__hasFogOfWarHiddenVehicles = False
self.__arenaInfo = None
self.__teamInfo = None
self.__settings = {}
self.__eventManager = Event.EventManager()
em = self.__eventManager
self.onArenaSettingsReceived = Event.Event(em)
self.onNewVehicleListReceived = Event.Event(em)
self.onVehicleAdded = Event.Event(em)
self.onVehicleUpdated = Event.Event(em)
self.onPositionsUpdated = Event.Event(em)
self.onPeriodChange = Event.Event(em)
self.onNewStatisticsReceived = Event.Event(em)
self.onVehicleStatisticsUpdate = Event.Event(em)
self.onVehicleKilled = Event.Event(em)
self.onVehicleHealthChanged = Event.Event(em)
self.onVehicleRecovered = Event.Event(em)
self.onAvatarReady = Event.Event(em)
self.onTeamBasePointsUpdate = Event.Event(em)
self.onTeamBasePointsUpdateAlt = Event.Event(em)
self.onTeamBaseCaptured = Event.Event(em)
self.onTeamKiller = Event.Event(em)
self.onCombatEquipmentUsed = Event.Event(em)
self.onInteractiveStats = Event.Event(em)
self.onGameModeSpecifcStats = Event.Event(em)
self.onViewPoints = Event.Event(em)
self.onFogOfWarEnabled = Event.Event(em)
self.onFogOfWarHiddenVehiclesSet = Event.Event(em)
self.onTeamHealthPercentUpdate = Event.Event(em)
self.onChatCommandTargetUpdate = Event.Event(em)
self.onChatCommandTriggered = Event.Event(em)
self.onRadarInfoReceived = Event.Event(em)
self.arenaUniqueID = arenaUniqueID
self._vsePlans = makeMultiPlanProvider(ASPECT.CLIENT, CallableProviderType.ARENA, arenaBonusType)
self.arenaType = ArenaType.g_cache.get(arenaTypeID, None)
self.bonusType = arenaBonusType
self.guiType = arenaGuiType
self.extraData = arenaExtraData
self.__arenaBBCollider = None
self.__spaceBBCollider = None
if spaceID == 0:
spaceID = self.DEFAULT_ARENA_WORLD_ID
self.gameSpace = CGF.World(spaceID)
self.componentSystem = assembler.createComponentSystem(self, self.bonusType, self.arenaType)
return
def _destroySystems(self):
self.__systemStarted = False
if self.trackScrollController is not None:
self.trackScrollController.deactivate()
self.__trackScrollCtl = None
for modelAnimator in self.__modelAnimators:
modelAnimator.animator.stop()
if self.__periodicTimerID is not None:
BigWorld.cancelCallback(self.__periodicTimerID)
self.__periodicTimerID = None
self.__modelAnimators = []
self.filter.enableLagDetection(False)
for go in self.undamagedStateChildren:
CGF.removeGameObject(go)
self.undamagedStateChildren = []
return
def __onResourcesLoaded(self, buildInd, resourceRefs):
for prevGo in self.undamagedStateChildren:
CGF.removeGameObject(prevGo)
self.undamagedStateChildren = []
self.removeComponentByType(GenericComponents.HierarchyComponent)
self.removeComponentByType(GenericComponents.TransformComponent)
self.createComponent(GenericComponents.HierarchyComponent, self.__vEntity.entityGameObject)
self.createComponent(GenericComponents.TransformComponent, Math.Vector3(0, 0, 0))
if not self.__vDesc:
self.__fireResourcesLoadedEvent()
return
elif buildInd != self.__curBuildInd:
return
else:
failedIDs = resourceRefs.failedIDs
resources = self.__resources
succesLoaded = True
for resID, resource in resourceRefs.items():
if resID not in failedIDs:
resources[resID] = resource
_logger.error('Could not load %s', resID)
succesLoaded = False
if self.collisions:
BigWorld.removeCameraCollider(self.collisions.getColliderID())
self._modelCollisions = resourceRefs['ModelCollisions']
hasCrashedCollisions = resourceRefs.has_key('CrashedModelCollisions')
if hasCrashedCollisions:
self._crashedModelCollisions = resourceRefs['CrashedModelCollisions']
if self.__isVehicleDestroyed and hasCrashedCollisions:
self.collisions = self.createComponent(BigWorld.CollisionComponent, self._crashedModelCollisions)
else:
self.collisions = self.createComponent(BigWorld.CollisionComponent, self._modelCollisions)
if succesLoaded:
self.__setupModel(buildInd)
if self.turretRotator is not None:
self.turretRotator.destroy()
self.turretRotator = SimpleTurretRotator(self.compoundModel, self.__staticTurretYaw, self.__vDesc.hull.turretPositions[0], self.__vDesc.hull.turretPitches[0], easingCls=math_utils.Easing.squareEasing)
self.__applyAttachmentsVisibility()
self.__fireResourcesLoadedEvent()
super(HangarVehicleAppearance, self).activate()
return
def bindAsTerrainEffect(self, position, spaceId, scale=None, loopCount=1):
if self.createTerrainEffect(position, scale, loopCount):
effectHandler = CGF.GameObject(spaceId)
effectHandler.createComponent(_SequenceAnimatorTimer,
self.__sequenceAnimator,
effectHandler)
effectHandler.activate()
effectHandler.transferOwnershipToWorld()
self.__sequenceAnimator = None
return
def __new__(metacls, name, bases, attrs):
global g_propertyIndex
messages.append('InitMetaclass {0}'.format(name))
cls = type.__new__(metacls, name, bases, attrs)
if name == 'CGFComponent':
CGF.registerBaseComponent(cls)
return cls
elif name == 'Rule':
return cls
else:
meta = []
allMeta = []
basePropIndex = 0
for base in bases:
baseMeta = getattr(base, '__meta', None)
if baseMeta is not None:
basePropIndex += len(baseMeta)
allMeta.extend(baseMeta)
for key, value in attrs.items():
if isinstance(value, ComponentProperty):
setattr(cls, key, None)
value.name = key
value.ownerName = name
value.applyIndex(basePropIndex)
meta.append(value)
allMeta.extend(meta)
setattr(cls, '__meta', allMeta)
category = getattr(cls, 'category', 'Python')
editorTitle = getattr(cls, 'editorTitle', name)
modulePath = getattr(cls, 'modulePath', None)
version = getattr(cls, 'version', 1)
userVisible = getattr(cls, 'userVisible', True)
vseVisible = getattr(cls, 'vseVisible', True)
if modulePath is None:
modulePath = sys.modules[
cls.
__module__].__file__ if cls.__module__ != '__builtin__' else '__builtin__'
CGF.registerComponent(cls, modulePath, name, editorTitle,
userVisible, vseVisible, category, version)
g_propertyIndex = 0
return cls
def loadPostEffect(cls, postEffectTarget):
if postEffectTarget is None or not postEffectTarget.isValid():
_logger.warning(
'postEffectTarget is not provided in HealthRestoreAbility Component'
)
return
else:
def postloadSetup(postEffectGO):
postEffectGO.createComponent(
AdaptationHealthRestoreEffectArea,
teamMateRestoringRadius=cls.getEquipment(
).teamMateRestoringRadius)
transformComponent = postEffectTarget.findComponentByType(
GenericComponents.TransformComponent)
CGF.loadGameObject(cls.getEquipment().posteffectPrefab,
postEffectTarget.spaceID,
transformComponent.worldPosition, postloadSetup)
return
class TestTriggersManager(CGF.ComponentManager):
whileInTrigger = CGF.QueryConfig(TestRotateWhileInTrigger,
Triggers.AreaTriggerComponent,
TestScriptAxisRotator)
@tickGroup('Simulation')
def tick(self):
for config, trigger, rotator in self.whileInTrigger:
if trigger.objectsInProximity:
rotator.rotationSpeedYaw = config.rotationSpeed
rotator.rotationSpeedYaw = 0.0
def _onLoaded(gameObject):
import Vehicle
h = CGF.HierarchyManager(self.spaceID)
vehicleGo = h.getTopMostParent(who)
vehicle = vehicleGo.findComponentByType(Vehicle.Vehicle)
appearance = vehicle.appearance
appearance.undamagedStateChildren.append(gameObject)
gameObject.createComponent(
GenericComponents.RedirectorComponent, who)
gameObject.createComponent(
GenericComponents.DynamicModelComponent, vehicle.model)
def __createMarkerArea(self, config, equipmentDescr):
markerArea = CGF.GameObject(self.__spaceID)
effect3D = self.__getEffect(config.getBotDeliveryMarker())
if effect3D is not None:
effectPath = effect3D.path
markerTerrainPosition = self.__deliveryPosition - equipmentDescr.botSpawnPointOffset
BigWorld.loadResourceListBG((AnimationSequence.Loader(effectPath, self.__spaceID),), makeCallbackWeak(self.__on3dEffectLoaded, equipmentDescr, effectPath, markerTerrainPosition))
return markerArea
else:
_logger.error('Marker Effect is not defined!')
return
def reset(self, recreate=True):
for descriptorName in self.__touchedDescriptors:
setattr(self, descriptorName, None)
spaceID = self._nativeSystem.spaceID
self._components = []
self._nativeSystem.destroy()
if recreate:
self._nativeSystem = CGF.GameObject(spaceID)
else:
self._nativeSystem = None
return
def __componentCreationEnter(self, creator, who, where):
_logger.debug('TestComponentCreation. Trigger entered')
if where.findComponentByType(TestScriptAxisRotator) is not None:
return
else:
rotator = where.createComponent(TestScriptAxisRotator)
rotator.rotationSpeedYaw = creator.rotationSpeed
rotator.rotationSpeedPitch = 0
rotator.rotationSpeedRoll = creator.rotationSpeed
rotator.transform = CGF.ComponentLink(
where, GenericComponents.TransformComponent)
return
def getPartGameObject(self, partName, spaceID, parentGO):
go = self.__gameObjects.get(partName)
if go is None or not go.isValid():
go = CGF.GameObject(spaceID)
go.activate()
go.createComponent(GenericComponents.HierarchyComponent, parentGO)
go.createComponent(GenericComponents.NodeFollower, partName,
parentGO)
go.createComponent(GenericComponents.TransformComponent,
Math.Vector3(0, 0, 0))
self.__gameObjects[partName] = go
return go
def __onDeliverEffectLoaded(self, effectP, position, resourceRefs):
if effectP in resourceRefs.failedIDs:
_logger.error('Effect %s has not been loaded!', effectP)
return
effectAnimation = CGF.GameObject(self.__spaceID)
sequenceComponent = effectAnimation.createComponent(SequenceComponent, resourceRefs[effectP])
correctedPosition = position + Math.Vector3(0, self.ALTITUDE_CORRECTING, 0)
sequenceComponent.createTerrainEffect(correctedPosition, loopCount=1, rotation=(self.__yawAxis, 0, 0))
effectAnimation.activate()
self.__deliveryEffect = effectAnimation
timeToSpawn = self.__deliveryTime - BigWorld.serverTime()
self.delayCallback(timeToSpawn + self.END_ANIMATION_TIME_CORRECTING, self.__removeDeliveryEffect)
def __multipositionSpawn(self, go, multivisualizer, influenceZone,
equipment, radius):
for zonePosition in influenceZone.zonesPosition:
localPosition = zonePosition - influenceZone.position
if multivisualizer.rotateFromCenter:
transform = math_utils.createRTMatrix(
(localPosition.yaw, 0, 0), localPosition)
else:
transform = math_utils.createTranslationMatrix(localPosition)
def postloadSetup(go):
areaVisualizer = go.findComponentByType(AreaAbilityVisualizer)
if areaVisualizer is not None:
areaVisualizer.radius = equipment.zoneRadius
eqComponent = go.createComponent(
InfluenceZoneEquipmentComponent)
eqComponent.setupEquipment(equipment)
return
CGF.loadGameObjectIntoHierarchy(multivisualizer.influencePrefab,
go, transform, postloadSetup)