def NewDirectionObstacleCheck(self, destYaw, heading): """ Calculates the direction we want to move in, performs a raycast to a specified length. The compares the collision normal if there is one with the direction vector to determine if angle between them is such where we will allow the character to walk and graze the wall. """ entity = self.entityClient.GetPlayerEntity() gw = GameWorld.Manager.GetGameWorld(long(entity.scene.sceneID)) posComp = entity.GetComponent('position') movComp = entity.GetComponent('movement') start = posComp.position start = geo2.Vec3Add( start, (0.0, self.AVATAR_COLLISION_DETECTION_CAPSULE_HEIGHT_MOD * movComp.characterController.height, 0.0)) yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll( posComp.rotation) direction = geo2.QuaternionRotationSetYawPitchRoll(yaw + destYaw, 0, 0) end = heading end = geo2.QuaternionTransformVector(direction, end) direction = end = geo2.Vec3Scale( end, self.AVATAR_COLLISION_DETECTION_FEELER_LENGTH) end = geo2.Vec3Add(end, start) hitResult = gw.SweptSphere( start, end, self.AVATAR_COLLISION_DETECTION_FEELER_RADIUS) result = False if hitResult: dotProduct = geo2.Vec3Dot(direction, hitResult[1]) if abs(dotProduct) > self.AVATAR_COLLISION_RESTRICTION_ANGLE_DP: result = True return result
def Transit(self, atPos0, eyePos0, atPos1, eyePos1, duration=1.0, smoothing=0.1, numPoints=1000, timeOffset=0.0, callback=None): newDir = geo2.Vec3Direction(eyePos1, atPos1) self.StopEyeAndAtAnimation() if self._atTransitOffset: atPos0 = geo2.Vec3Add(atPos0, self._atTransitOffset) if self._eyeTransitOffset: eyePos0 = geo2.Vec3Add(eyePos0, self._eyeTransitOffset) self.SetAtPosition(atPos1) self.SetEyePosition(eyePos1) self._atTransitOffset = geo2.Vec3Subtract(atPos0, atPos1) self._eyeTransitOffset = geo2.Vec3Subtract(eyePos0, eyePos1) uicore.animations.MorphVector3(self, '_atTransitOffset', self._atTransitOffset, (0, 0, 0), duration=duration, timeOffset=timeOffset, callback=callback) uicore.animations.MorphVector3(self, '_eyeTransitOffset', self._eyeTransitOffset, (0, 0, 0), duration=duration, timeOffset=timeOffset, callback=self.OnTransitEnd) self._transitDoneTime = blue.os.GetWallclockTime() + SEC * duration
def update_line_position(posInfo): lineData = posInfo[2] lineID = lineData.lineID fromPosition = posInfo[0] if fromPosition is None: fromMapNode = GetNodeBySolarSystemID(lineData.fromSolarSystemID) fromPosition = fromMapNode.position posInfo[0] = fromPosition toPosition = posInfo[1] if toPosition is None: toMapNode = GetNodeBySolarSystemID(lineData.toSolarSystemID) toPosition = toMapNode.position posInfo[1] = toPosition if lineID in adjustLines: fromPosition = geo2.Vec3Add(fromPosition, adjustLines[lineID][0]) toPosition = geo2.Vec3Add(toPosition, adjustLines[lineID][2]) lineSet.ChangeLinePositionCrt(lineID, fromPosition, toPosition) if lineData.jumpType == JUMPBRIDGE_TYPE: linkVec = geo2.Vec3Subtract(toPosition, fromPosition) normLinkVec = geo2.Vec3Normalize(linkVec) rightVec = geo2.Vec3Cross(worldUp, normLinkVec) upVec = geo2.Vec3Cross(rightVec, normLinkVec) offsetVec = geo2.Vec3Scale(geo2.Vec3Normalize(upVec), geo2.Vec3Length(linkVec) * 1.0) midPos = geo2.Vec3Scale(geo2.Vec3Add(toPosition, fromPosition), 0.5) splinePos = geo2.Vec3Add(midPos, offsetVec) lineSet.ChangeLineIntermediateCrt(lineID, splinePos)
def NewDirectionObstacleCheck(self, destYaw, heading): entity = self.entityClient.GetPlayerEntity() gw = GameWorld.Manager.GetGameWorld(long(entity.scene.sceneID)) posComp = entity.GetComponent('position') movComp = entity.GetComponent('movement') start = posComp.position start = geo2.Vec3Add( start, (0.0, self.AVATAR_COLLISION_DETECTION_CAPSULE_HEIGHT_MOD * movComp.characterController.height, 0.0)) yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll( posComp.rotation) direction = geo2.QuaternionRotationSetYawPitchRoll(yaw + destYaw, 0, 0) end = heading end = geo2.QuaternionTransformVector(direction, end) direction = end = geo2.Vec3Scale( end, self.AVATAR_COLLISION_DETECTION_FEELER_LENGTH) end = geo2.Vec3Add(end, start) hitResult = gw.SweptSphere( start, end, self.AVATAR_COLLISION_DETECTION_FEELER_RADIUS) result = False if hitResult: dotProduct = geo2.Vec3Dot(direction, hitResult[1]) if abs(dotProduct) > self.AVATAR_COLLISION_RESTRICTION_ANGLE_DP: result = True return result
def PanUpdateThread(self): try: while True: if self.panTarget is None: break if self._IsPanTargetOutOfBounds(): return distLeft = geo2.Vec3LengthD(self.panTarget) if distLeft == 0: break if distLeft < self.kPanStopDist: dist = 1.0 else: dist = min(1.0, self._GetPanSpeed() / blue.os.fps) toMove = geo2.Vec3ScaleD(self.panTarget, dist) self.SetEyePosition(geo2.Vec3Add(self._eyePosition, toMove)) self.SetAtPosition(geo2.Vec3Add(self._atPosition, toMove)) self.panTarget = geo2.Vec3SubtractD(self.panTarget, toMove) if dist == 1.0: break blue.synchro.Yield() finally: self.panUpdateThread = None self.panTarget = None
def Update(self): normalCamera = self._GetNonDebugCamera() if not self.IsUpdatingDebugCamera() and normalCamera: if normalCamera: normalCamera.Update() if self.IsShowingNormalCamera() and normalCamera: camPos = normalCamera.GetPosition() poi = normalCamera.GetPointOfInterest() vec = geo2.Vec3Subtract(poi, camPos) vec = geo2.Vec3Normalize(vec) vec = geo2.Vec3Scale(vec, 0.5) self.debugRenderClient.RenderCone(camPos, geo2.Vec3Add(camPos, vec), 0.25, 4278190335L, time=1) if self.lastCamPos is not None and camPos != self.lastCamPos: self.debugRenderClient.RenderRay(self.lastCamPos, camPos, 4278190335L, 4278255360L, time=1000, pulse=True) self.lastCamPos = camPos if self.translationVector != [0.0, 0.0, 0.0]: now = blue.os.GetWallclockTime() frameTime = float(now - self.lastUpdateTime) / const.SEC poi = cameras.PolarCamera.GetPointOfInterest(self) rotMatrix = geo2.MatrixRotationYawPitchRoll( math.pi / 2.0 - self.yaw, math.pi / 2.0 - self.pitch, 0.0) scaledVector = geo2.Vec3Scale(self.translationVector, frameTime) relativeVector = geo2.Vec3TransformCoord(scaledVector, rotMatrix) newPos = geo2.Vec3Add(poi, relativeVector) cameras.PolarCamera.SetPointOfInterest(self, newPos) cameras.PolarCamera.Update(self)
def Update(self): cameras.BasicCamera.Update(self) self.TurnOffAvatar() if not trinity.app.IsActive(): return fwdActive, backActive, moveLActive, moveRActive = self.navigation.GetKeyState( ) speed = cameras.FLY_CAMERA_ACCELERATION * cameras.FLY_CAMERA_BASE_MOVEMENT_SPEED if fwdActive: self.cameraPosition = geo2.Vec3Add(self.cameraPosition, (val * -speed for val in self.direction)) elif backActive: self.cameraPosition = geo2.Vec3Add(self.cameraPosition, (val * speed for val in self.direction)) if moveLActive: rotateLeft = (-self.direction[2], self.direction[1], self.direction[0]) translation = geo2.Vec3Add(self.cameraPosition, (val * speed for val in rotateLeft)) self.cameraPosition = (translation[0], self.cameraPosition[1], translation[2]) elif moveRActive: rotateRight = (self.direction[2], self.direction[1], -self.direction[0]) translation = geo2.Vec3Add(self.cameraPosition, (val * speed for val in rotateRight)) self.cameraPosition = (translation[0], self.cameraPosition[1], translation[2])
def Pan(self, diff): """ Pan the camera by a vector in world space """ pos = self.GetPosition() self.SetPosition(geo2.Vec3Add(pos, diff)) self.pointOfInterest = geo2.Vec3Add(self.pointOfInterest, diff)
def _DrawVelocityTrace(self): while True: try: entity = self.debugSelectionClient.GetSelectedEntity() if entity is not None: if not entity.HasComponent('movement'): return scaleFactor = 1.5 / 4.0 offset = 0.25 pos = entity.position.position vel = entity.GetComponent('movement').physics.velocity speed = geo2.Vec3Length(vel) speedScaled = speed * scaleFactor velPos = geo2.Vec3Add(pos, (0, offset + speedScaled, 0)) velRulePos = geo2.Vec3Add(pos, (0, offset + 1, 0)) if self.lastVelPos != velPos: self.debugRenderClient.RenderRay(self.lastVelPos, velPos, 4278190335L, 4278190335L, time=1000, pulse=True) self.debugRenderClient.RenderRay(self.lastVelRulePos, velRulePos, 4278255360L, 4278255360L, time=1000, pulse=False) self.lastVelPos = velPos self.lastVelRulePos = velRulePos except: log.LogException() blue.pyos.synchro.SleepWallclock(const.ONE_TICK / const.MSEC)
def getPoint(i): p = obb[3] x = obb[0] y = obb[1] z = obb[2] size = obb[4] p = geo2.Vec3Add(p, geo2.Vec3Scale(x, size[0] if i & 1 else -size[0])) p = geo2.Vec3Add(p, geo2.Vec3Scale(y, size[1] if i & 2 else -size[1])) p = geo2.Vec3Add(p, geo2.Vec3Scale(z, size[2] if i & 4 else -size[2])) return p
def DrawCircularArc(lineSet, centerPosition, radius, angle, startAngle = 0.0, lineWidth = 1.0, startColor = (0.3, 0.3, 0.3, 0.5), endColor = (0.3, 0.3, 0.3, 0.5)): cos = math.cos(startAngle) sin = math.sin(startAngle) p1 = geo2.Vec3Add(centerPosition, (-radius * cos, 0.0, -radius * sin)) cos = math.cos(startAngle + angle) sin = math.sin(startAngle + angle) p2 = geo2.Vec3Add(centerPosition, (-radius * cos, 0.0, -radius * sin)) lineID = lineSet.AddSpheredLineCrt(p1, startColor, p2, endColor, centerPosition, lineWidth) lineSet.ChangeLineSegmentation(lineID, int(math.degrees(angle))) return lineID
def MoveTF(self, tf, dx, dy): camera = sm.GetService('sceneManager').GetRegisteredCamera('starmap') X = float(dx) / float(trinity.device.width) Y = -float(dy) / float(trinity.device.height) viewVec = camera.viewVec upVec = geo2.Vec3Scale(camera.upVec, Y) rightVec = geo2.Vec3Scale(camera.rightVec, X) pos = geo2.Vec3Add(rightVec, upVec) pos = geo2.Vec3Scale(pos, pow(tf.cameraDistSq, 0.5) * 1.5) pos = geo2.QuaternionTransformVector(camera.rotationAroundParent, pos) tf.translation = geo2.Vec3Add(tf.translation, pos)
def UpdateAtEyePositions(self): trackPos = self.GetTrackPosition() lookDir = self.GetLookDirection() ballPos = GetBallPosition(self.trackBall) if self.trackBall.model: radius = self.trackBall.model.GetBoundingSphereRadius() else: radius = self.trackBall.radius * 1.2 self.SetEyePosition( geo2.Vec3Add(ballPos, geo2.Vec3Scale(lookDir, -radius))) self.SetAtPosition( geo2.Vec3Add(ballPos, geo2.Vec3Scale(lookDir, -2 * radius)))
def Zoom(self, val): dev = trinity.device pos = self.GetPosition() target = self.GetPointOfInterest() view = geo2.Vec3Normalize(geo2.Subtract(pos, target)) length = geo2.Vec3Length(geo2.Subtract(pos, target)) nextPos = geo2.Vec3Add(pos, geo2.Vec3Scale(view, length * val)) nextLength = geo2.Vec3Length(geo2.Vec3Subtract(nextPos, target)) if nextLength < self.minZoomDistance: nextPos = geo2.Vec3Add(target, geo2.Vec3Scale(view, self.minZoomDistance)) elif nextLength > self.maxZoomDistance: nextPos = geo2.Vec3Add(target, geo2.Vec3Scale(view, self.maxZoomDistance)) self.SetPosition(nextPos)
def GetSynchedAnimStartLocation(sourcePos, sourceRot, targetPos, targetRot, animInfo): relVec = geo2.Vec3Subtract(sourcePos, targetPos) curDist = geo2.Vec3Length(relVec) if curDist <= 0.01: sourcePos = geo2.Vec3Add(targetPos, (0, 0, -1)) relVec = geo2.Vec3Subtract(sourcePos, targetPos) entName = const.animation.ATTACKER_NAME if entName in animInfo and const.animation.METADATA_TURN_TO_FACE in animInfo[entName] and animInfo[entName][const.animation.METADATA_TURN_TO_FACE] == False: newSourceRot = sourceRot else: newSourceRot = GetQuatFromDirection(sourcePos, targetPos) entName = const.animation.VICTIM_NAME if entName in animInfo and const.animation.METADATA_TURN_TO_FACE in animInfo[entName] and animInfo[entName][const.animation.METADATA_TURN_TO_FACE] == False: newTargetRot = targetRot newTargetYaw, trash, trash = geo2.QuaternionRotationGetYawPitchRoll(targetRot) else: newTargetRot = GetQuatFromDirection(targetPos, sourcePos) if entName in animInfo and const.animation.METADATA_START_OFFSET_YAW in animInfo[entName]: degrees = animInfo[entName][const.animation.METADATA_START_OFFSET_YAW] offsetYaw = math.pi * -degrees / 180.0 offsetRot = geo2.QuaternionRotationSetYawPitchRoll(offsetYaw, 0.0, 0.0) newTargetRot = geo2.QuaternionMultiply(newTargetRot, offsetRot) distance = 0.5 if const.animation.METADATA_START_DISTANCE in animInfo: distance = animInfo[const.animation.METADATA_START_DISTANCE] entName = const.animation.VICTIM_NAME if entName in animInfo and const.animation.METADATA_START_OFFSET_YAW in animInfo[entName]: if '/righthanded' in blue.pyos.GetArg(): front = (0, 0, distance) else: front = (0, 0, -distance) degrees = animInfo[entName][const.animation.METADATA_START_OFFSET_YAW] radians = math.pi * degrees / 180.0 offsetRot = geo2.QuaternionRotationSetYawPitchRoll(radians, 0.0, 0.0) yawOffsetQuat = geo2.QuaternionMultiply(newTargetRot, offsetRot) radOffset = geo2.QuaternionTransformVector(yawOffsetQuat, front) newSourcePos = geo2.Vec3Add(targetPos, radOffset) newSourceRot = GetQuatFromDirection(newSourcePos, targetPos) else: direction = geo2.Vec3Normalize(relVec) newSourcePos = geo2.Vec3Add(targetPos, (distance * direction[0], distance * direction[1], distance * direction[2])) entName = const.animation.ATTACKER_NAME if entName in animInfo and const.animation.METADATA_START_OFFSET_YAW in animInfo[entName]: degrees = animInfo[entName][const.animation.METADATA_START_OFFSET_YAW] radians = math.pi * -degrees / 180.0 offsetRot = geo2.QuaternionRotationSetYawPitchRoll(radians, 0.0, 0.0) newSourceRot = geo2.QuaternionMultiply(newSourceRot, offsetRot) return (newSourcePos, newSourceRot, targetPos, newTargetRot)
def UpdateSolarSystemPosition(self, solarSystemPosition): self.mapPositionSolarSystem = solarSystemPosition self.position = geo2.Vec3Add(solarSystemPosition, self.mapPositionLocal) self.projectBracket.trackPosition = self.position if self.trackingTransforms: for each in self.trackingTransforms: each.translation = self.position
def Update(self): BaseSpaceCamera.Update(self) if self.model and self.model.translationCurve: atPos = self.model.translationCurve.value diff = geo2.Vec3Subtract(atPos, self._atPosition) self.atPosition = atPos self.eyePosition = geo2.Vec3Add(self.eyePosition, diff)
def Update(self): self._UpdateAnchorPosition() BaseSpaceCamera.Update(self) if not self.lookAtBall or not self.ego: return zoomProp = self.GetZoomProportion() self._UpdateAtOffset() self._UpdateEyeOffset() newAtPos = self.GetTrackPosition(self.lookAtBall) atDiff = geo2.Vec3Subtract(newAtPos, self._atPosition) self.SetAtPosition(newAtPos) if self.IsChasing(): self.SetEyePosition( self.trackLerper.GetValue(self._eyePosition, self.GetChaseEyePosition())) elif self.IsTracking(): self.SetEyePosition( self.trackLerper.GetValue(self._eyePosition, self.GetTrackingEyePosition())) else: prop = self._GetEyePosDriftProporition() eyeOffset = geo2.Vec3Scale(atDiff, prop) self.SetEyePosition(geo2.Vec3Add(self._eyePosition, eyeOffset)) if not self.IsInTransit(): if self.GetItemID() == self.ego or self.IsTracking( ) or self.IsChasing(): self.SetZoom(zoomProp) self.EnforceMinZoom() if not self.isManualFovEnabled and IsDynamicCameraMovementEnabled(): self.SetFovTarget(self.GetDynamicFov())
def SetYaw(self, yaw): rotMat = geo2.MatrixRotationY(yaw - math.pi) eyePos = geo2.Vec3Subtract(self._eyePosition, self._atPosition) x = math.sqrt(eyePos[0]**2 + eyePos[2]**2) vec = (0, eyePos[1], x) self._eyePosition = geo2.Vec3Add(geo2.Vec3Transform(vec, rotMat), self._atPosition)
def _GetBonePosRot(self, ENTID, boneName, posProp, rotProp): entity = self.entityService.FindEntityByID(ENTID) if entity is None: self.LogError('GetBonePosRot: Entity with ID ', ENTID, ' not found!') return False animClient = entity.GetComponent('animation') posComp = entity.GetComponent('position') if animClient is not None and posComp is not None: if animClient.controller is not None: boneTransform = animClient.controller.animationNetwork.GetBoneTransform( boneName) if boneTransform: translation, orientation = boneTransform translation = geo2.QuaternionTransformVector( posComp.rotation, translation) translation = geo2.Vec3Add(posComp.position, translation) orientation = geo2.QuaternionMultiply( posComp.rotation, orientation) translation = list(translation) orientation = list(orientation) GameWorld.AddPropertyForCurrentPythonProc( {posProp: translation}) GameWorld.AddPropertyForCurrentPythonProc( {rotProp: orientation}) return True self.LogError('GetBonePosRot: Missing critical data in entity!') return False
def SetPitch(self, pitch): pitch = self.ClampPitch(pitch) axis = geo2.Vec3Cross(self.upDirection, self.GetLookAtDirection()) rotMat = geo2.MatrixRotationAxis(axis, pitch) vec = (0, self.GetZoomDistance(), 0) self._eyePosition = geo2.Vec3Add(self._atPosition, geo2.Vec3Transform(vec, rotMat))
def MoveCursor(self, tf, dx, dy, camera): dev = trinity.device X = float(dx) / float(dev.width) Y = float(dy) / float(dev.height) * -1 upVec = geo2.Vec3Scale(camera.upVec, Y) rightVec = geo2.Vec3Scale(camera.rightVec, X) pos = geo2.Vec3Add(rightVec, upVec) cameraDistance = geo2.Vec3Length(geo2.Vec3Subtract(camera.pos, self.cursor.translation)) pos = geo2.Vec3Scale(pos, cameraDistance * 3.0) if tf in self.yCursor: pos = (0.0, pos[1], 0.0) elif tf in self.xCursor: pos = (pos[0], 0.0, 0.0) elif tf in self.zCursor: pos = (0.0, 0.0, pos[2]) self.cursor.translation = geo2.Vec3Add(self.cursor.translation, pos)
def TransformAccumulatedAnimFromPos(curPos, curRot, offsetTranslation, offsetYaw): offsetYaw = offsetYaw * math.pi / 180.0 trajRot = geo2.QuaternionRotationSetYawPitchRoll(offsetYaw, 0.0, 0.0) offsetPosRotated = geo2.QuaternionTransformVector(curRot, offsetTranslation) newPos = geo2.Vec3Add(curPos, offsetPosRotated) newRot = geo2.QuaternionMultiply(trajRot, curRot) return (newPos, newRot)
def UpdateModelPosition(self, pos): self.UpdateModel() if self.model: pos = geo2.Vec3Add(pos, self.movingOffset) pos = self.EnforcePositionRestrictions(pos) if pos: self.model.translationCurve.value = pos
def PlaySoundFX(self, targetObject, spewCone): position, direction = spewCone audioEmitter = audio2.AudEmitter(targetObject.name + '_src') translatedPosition = geo2.Vec3Add(targetObject.worldPosition, position) audioEmitter.SetPosition(direction, translatedPosition) audioEmitter.SetAttenuationScalingFactor(10000) audioEmitter.SendEvent('scattering_spew_play')
def LoadMarkers(self): if self.markersHandler and self.localMarkerIDs: for markerID in self.localMarkerIDs: self.markersHandler.RemoveMarker(markerID) self.localMarkerIDs = set() solarSystemData = self.systemMapSvc.GetSolarsystemData( self.solarsystemID) loadMarkerGroups = GetMapViewSetting(VIEWMODE_MARKERS_SETTINGS) for each in solarSystemData: if self.markersHandler and each.groupID in loadMarkerGroups: bracketData = sm.GetService('bracket').GetMappedBracketProps( cfg.invgroups.Get(each.groupID).categoryID, each.groupID, each.typeID) markerID = (MARKERID_SOLARSYSTEM_CELESTIAL, each.itemID) markerObject = self.markersHandler.AddMarker( markerID, geo2.Vec3Add( self.position, SolarSystemPosToMapPos((each.x, each.y, each.z))), MarkerCelestial, texturePath=bracketData[0], celestialData=each, distanceFadeAlpha=True, maxVisibleRange=2500) markerObject.SetSolarSystemID(self.solarsystemID) self.localMarkerIDs.add(markerID)
def _UpdateCameraNoiseOffset(self): if self.noiseScaleCurve: self.noiseScale = self.noiseScaleCurve.UpdateScalar( blue.os.GetSimTime()) if self.noiseScale == 0: return if self.noiseDampCurve: self.noiseDamp = self.noiseDampCurve.UpdateScalar( blue.os.GetSimTime()) dT = 1.0 / blue.os.fps ran = random.random() - 0.5 self._noiseX = (self._noiseX + self.noiseDamp * ran) / (1.0 + self.noiseDamp * dT) self._noiseX = max(-MAX_NOISE, min(self._noiseX, MAX_NOISE)) ran = random.random() - 0.5 self._noiseY = (self._noiseY + self.noiseDamp * ran) / (1.0 + self.noiseDamp * dT) self._noiseY = max(-MAX_NOISE, min(self._noiseY, MAX_NOISE)) noiseScale = self.GetZoomDistance() / 100.0 * self.noiseScale direction = self.GetLookAtDirection() vecX = geo2.Vec3Cross(direction, self._upDirection) vecY = geo2.Vec3Cross(direction, vecX) vecX = geo2.Vec3Scale(vecX, self._noiseX * noiseScale) vecY = geo2.Vec3Scale(vecY, self._noiseY * noiseScale) noiseOffset = geo2.Vec3Add(vecX, vecY) self._AddToAtOffset(noiseOffset)
def UpdateMapPositionLocal(self, mapPositionLocal): self.mapPositionLocal = mapPositionLocal self.position = geo2.Vec3Add(self.mapPositionSolarSystem, mapPositionLocal) self.projectBracket.trackPosition = self.position if self.trackingTransforms: for each in self.trackingTransforms: each.translation = self.position
def ShowMyHomeStation(self): if self.destroyed: return markerID = (MARKERID_MYHOME, session.charid) self.markersHandler.RemoveMarker(markerID) try: self.markersAlwaysVisible.remove(markerID) except: pass homeStationID = sm.RemoteSvc('charMgr').GetHomeStation() if not homeStationID or self.destroyed: return stationInfo = self.mapSvc.GetStation(homeStationID) if self.destroyed: return if stationInfo.solarSystemID != self.currentSolarsystem.solarsystemID: return mapPosition = (0, 0, 0) localPosition = SolarSystemPosToMapPos( (stationInfo.x, stationInfo.y, stationInfo.z)) mapPosition = geo2.Vec3Add(mapPosition, localPosition) markerObject = self.markersHandler.AddMarker( markerID, mapPosition, MarkerMyHome, stationInfo=stationInfo, texturePath='res:/UI/Texture/classes/MapView/homeIcon.png', hintString='Home Station', distanceFadeAlpha=False) markerObject.SetSolarSystemID(stationInfo.solarSystemID) self.markersAlwaysVisible.add(markerID)
def PickProbes(self, pickBorder = False): mouseInsideProbes = [] borderPick = [] probeHandler = self.GetProbeHandler() if probeHandler: probeData = sm.StartService('scanSvc').GetProbeData() cameraPosition = geo2.Vec3Add(self.mapView.camera.pointOfInterest, self.mapView.camera._eyePosition) probes = probeHandler.GetProbeControls() for probeID, probeControl in probes.iteritems(): if probeID not in probeData or probeData[probeID].state != const.probeStateIdle: continue targetPlanePos = probeControl.GetWorldPosition() cameraDistance = geo2.Vec3Length(geo2.Vec3Subtract(cameraPosition, targetPlanePos)) rad = probeControl.GetRange() * SOLARSYSTEM_SCALE mousePositionOnCameraPlane = self.GetDotInCameraAlignedPlaneFromPosition(targetPlanePos) distanceFromCenter = geo2.Vec3Length(geo2.Vec3Subtract(targetPlanePos, mousePositionOnCameraPlane)) if pickBorder: pickRadiusPos = self.GetDotInCameraAlignedPlaneFromPosition(targetPlanePos, offsetMouse=(-10, 0)) pickRadius = geo2.Vec3Length(geo2.Vec3Subtract(pickRadiusPos, mousePositionOnCameraPlane)) if rad + pickRadius > distanceFromCenter > rad - pickRadius: borderPick.append((abs(rad - distanceFromCenter), probeControl)) elif distanceFromCenter <= rad: mouseInsideProbes.append((cameraDistance, probeControl)) if pickBorder: if borderPick: return SortListOfTuples(borderPick)[0] else: return None return SortListOfTuples(mouseInsideProbes)