NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

deploymentEntity.py (10002B)


      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\ui\structure\deployment\deploymentEntity.py
      2 from carbon.common.script.util.mathUtil import RayToPlaneIntersection
      3 from evegraphics.utils import BuildSOFDNAFromTypeID
      4 from carbonui.uicore import uicore
      5 import evetypes
      6 from moonmining.const import MOONMINING_NEVER_AVAILABLE, MOONMINING_NOT_POSSIBLE
      7 from signals import Signal
      8 import structures
      9 import trinity
     10 import blue
     11 import geo2
     12 from eve.client.script.environment.sofService import GetSofService
     13 from structures.deployment import DEPLOY_DIST_MAX, IsDrillingPlatform
     14 import fsdBuiltData.common.graphicIDs as fsdGraphicIDs
     15 
     16 class StructurePlacementEntity(object):
     17 
     18     def __init__(self, typeID):
     19         self.typeID = typeID
     20         self.radius = evetypes.GetRadius(typeID)
     21         self.movingOffset = None
     22         self.cameraMatrixes = None
     23         self._opacity = 0.0
     24         self.blueprintColor = None
     25         self.ballpark = sm.GetService('michelle').GetBallpark()
     26         self.model_refinary_invalid = None
     27         self.model_valid = self._LoadModel(':variant?placement', display=True)
     28         self.model_invalid = self._LoadModel(':variant?forbiddenplacement', display=False)
     29         self.model_placement = self._LoadPlacementModel()
     30         self.on_location_updated = Signal(signalName='on_location_updated')
     31         self.UpdateModel()
     32 
     33     @property
     34     def model(self):
     35         if self.model_valid and self.model_valid.display:
     36             return self.model_valid
     37         if self.model_invalid and self.model_invalid.display:
     38             return self.model_invalid
     39         if self.model_refinary_invalid and self.model_refinary_invalid.display:
     40             return self.model_refinary_invalid
     41 
     42     def GetRefineryInvalidModel(self):
     43         if not getattr(self, 'model_refinary_invalid', None):
     44             self.model_refinary_invalid = self._LoadModel(':variant?refineryplacementunoptimal', display=False)
     45         return self.model_refinary_invalid
     46 
     47     def FindDeploymentConflict(self):
     48         ballsAndItems, position = self._GetPositionAndBalls()
     49         return structures.GetDeploymentConflictForBalls(self.ballpark, ballsAndItems, self.typeID, position)
     50 
     51     def GetMoonminingAvailabilityValue(self):
     52         if not IsDrillingPlatform(self.typeID):
     53             return MOONMINING_NEVER_AVAILABLE
     54         ballsAndItems, position = self._GetPositionAndBalls()
     55         return structures.GetMoonminingAvailabilityValueForBalls(ballsAndItems, self.typeID, position)
     56 
     57     def _GetPositionAndBalls(self):
     58         ship = self.ballpark.GetBall(session.shipid)
     59         position = geo2.Vec3AddD((ship.x, ship.y, ship.z), self.GetPosition())
     60         ballsAndItems = self.ballpark.GetBallsAndItems()
     61         return (ballsAndItems, position)
     62 
     63     def UpdateModel(self):
     64         conflict = self.FindDeploymentConflict()
     65         canMoonMine = self.GetMoonminingAvailabilityValue()
     66         isValidLocation = conflict is None
     67         changedModel = None
     68         if isValidLocation:
     69             if canMoonMine == MOONMINING_NOT_POSSIBLE:
     70                 modelToShow = self.GetRefineryInvalidModel()
     71                 modelToHide = self.model_valid
     72             else:
     73                 modelToShow = self.model_valid
     74                 modelToHide = self.model_refinary_invalid
     75             if not modelToShow.display:
     76                 self.TryHideModel(modelToHide)
     77                 self.model_invalid.display = False
     78                 modelToShow.display = True
     79                 modelToShow.translationCurve.value = self.model_invalid.translationCurve.value
     80                 modelToShow.modelRotationCurve.value = self.model_invalid.modelRotationCurve.value
     81             changedModel = self.model
     82         elif not self.model_invalid.display:
     83             self.TryHideModel(self.model_refinary_invalid)
     84             currentModel = self.model_valid if self.model_valid.display else self.model_refinary_invalid
     85             self.model_valid.display = False
     86             self.model_invalid.display = True
     87             self.model_invalid.translationCurve.value = currentModel.translationCurve.value
     88             self.model_invalid.modelRotationCurve.value = currentModel.modelRotationCurve.value
     89             changedModel = self.model_invalid
     90         if changedModel and self.model_placement:
     91             self.model_placement.translationCurve = changedModel.translationCurve
     92             self.model_placement.modelRotationCurve = changedModel.modelRotationCurve
     93         self.on_location_updated(conflict, canMoonMine)
     94 
     95     def TryHideModel(self, modelToHide):
     96         if not modelToHide:
     97             return
     98         modelToHide.display = False
     99 
    100     def GetCurrShipPosition(self):
    101         ball = self.ballpark.GetBall(session.shipid)
    102         pos = ball.GetVectorAt(blue.os.GetSimTime())
    103         pos = (pos.x, 0, pos.z)
    104         camOffset = self.GetCamera().eyePosition
    105         camOffset = (camOffset[0], 0.0, camOffset[2])
    106         camDist = geo2.Vec3Length(camOffset)
    107         return geo2.Vec3Subtract(pos, geo2.Vec3Scale(camOffset, (structures.GetDeploymentDistance(const.typeCapsule) + self.radius) / camDist))
    108 
    109     def _LoadModel(self, variant, display):
    110         scene = sm.GetService('sceneManager').GetRegisteredScene('default')
    111         if scene is None:
    112             return
    113         sof = GetSofService().spaceObjectFactory
    114         model = sof.BuildFromDNA(BuildSOFDNAFromTypeID(self.typeID) + variant)
    115         model.modelRotationCurve = trinity.Tr2RotationAdapter()
    116         model.translationCurve = trinity.Tr2TranslationAdapter()
    117         model.name = 'StructurePlacement'
    118         model.translationCurve.value = self.GetCurrShipPosition()
    119         model.display = display
    120         scene.objects.append(model)
    121         return model
    122 
    123     def _LoadPlacementModel(self):
    124         scene = sm.GetService('sceneManager').GetRegisteredScene('default')
    125         if scene is None:
    126             return
    127         graphicID = evetypes.GetGraphicID(self.typeID)
    128         states = fsdGraphicIDs.GetAnimationStateObjects(graphicID, {})
    129         dna = states.get('placement', '')
    130         if not dna:
    131             return
    132         sof = GetSofService().spaceObjectFactory
    133         model = sof.BuildFromDNA(dna)
    134         model.name = 'StructurePlacementBlinkies'
    135         model.display = True
    136         scene.objects.append(model)
    137         return model
    138 
    139     def Close(self):
    140         scene = sm.GetService('sceneManager').GetRegisteredScene('default')
    141         if scene:
    142             if self.model_valid:
    143                 scene.objects.fremove(self.model_valid)
    144             if self.model_invalid:
    145                 scene.objects.fremove(self.model_invalid)
    146             if self.model_placement:
    147                 scene.objects.fremove(self.model_placement)
    148             if self.model_refinary_invalid:
    149                 scene.objects.fremove(self.model_refinary_invalid)
    150 
    151     def UpdateModelPosition(self, pos):
    152         self.UpdateModel()
    153         if self.model:
    154             pos = geo2.Vec3Add(pos, self.movingOffset)
    155             pos = self.EnforcePositionRestrictions(pos)
    156             if pos:
    157                 self.model.translationCurve.value = pos
    158 
    159     def GetPosition(self):
    160         return self.model.translationCurve.value
    161 
    162     def GetRotation(self):
    163         return geo2.QuaternionRotationGetYawPitchRoll(self.model.modelRotationCurve.value)
    164 
    165     def EnforcePositionRestrictions(self, pos):
    166         vecLen = geo2.Vec3Length(pos)
    167         if vecLen > DEPLOY_DIST_MAX:
    168             return geo2.Vec3Scale(pos, DEPLOY_DIST_MAX / vecLen)
    169         else:
    170             return pos
    171 
    172     def UpdateModelRotation(self, dx):
    173         if self.model:
    174             rotation = geo2.QuaternionRotationAxis((0, 1.0, 0), dx)
    175             self.model.modelRotationCurve.value = geo2.QuaternionMultiply(self.model.modelRotationCurve.value, rotation)
    176 
    177     def SetModelRotation(self, yaw, pitch, roll):
    178         if self.model:
    179             rotation = geo2.QuaternionRotationSetYawPitchRoll(yaw, pitch, roll)
    180             self.model.modelRotationCurve.value = rotation
    181 
    182     def MoveDragObject(self):
    183         pYPlane, sign = self.GetMousePosToYPlaneIntersection()
    184         if sign > 0:
    185             self.UpdateModelPosition(pYPlane)
    186 
    187     def GetMousePosToYPlaneIntersection(self):
    188         ray, p0 = self.GetRayAndPointFromScreen()
    189         pYPlane, sign = self.GetIntersectionToYPlane(p0, ray)
    190         return (pYPlane, sign)
    191 
    192     def RotateDragObject(self):
    193         dx = float(uicore.uilib.dx * 0.01)
    194         self.UpdateModelRotation(dx)
    195 
    196     def GetRayAndPointFromScreen(self):
    197         x = float(uicore.uilib.x)
    198         y = float(uicore.uilib.y)
    199         data = self.GetCameraMatrixes()
    200         start = geo2.Vec3Unproject((x, y, 0.0), *data)
    201         end = geo2.Vec3Unproject((x, y, 100000.0), *data)
    202         ray = geo2.Vec3SubtractD(end, start)
    203         ray = geo2.Vector(*ray)
    204         start = geo2.Vector(*start)
    205         return (ray, start)
    206 
    207     def GetCameraMatrixes(self):
    208         if self.cameraMatrixes:
    209             return self.cameraMatrixes
    210         camera = self.GetCamera()
    211         viewPort = (0.0,
    212          0.0,
    213          float(uicore.desktop.width),
    214          float(uicore.desktop.height),
    215          0,
    216          100000.0)
    217         self.cameraMatrixes = (viewPort,
    218          camera.projectionMatrix.transform,
    219          camera.viewMatrix.transform,
    220          geo2.MatrixIdentity())
    221         return self.cameraMatrixes
    222 
    223     def GetCamera(self):
    224         return sm.GetService('sceneManager').GetActiveCamera()
    225 
    226     def GetIntersectionToYPlane(self, p0, ray):
    227         intersection, sign = RayToPlaneIntersection(p0, ray, (0, 0, 0), (0, 1.0, 0), returnSign=True)
    228         return (intersection, sign)
    229 
    230     def StartMoving(self):
    231         structPos = self.model.translationCurve.value
    232         structPos = (structPos[0], 0, structPos[2])
    233         mousePos, sign = self.GetMousePosToYPlaneIntersection()
    234         if sign > 0:
    235             self.movingOffset = geo2.Vec3Subtract(structPos, mousePos)
    236 
    237     def EndMoving(self):
    238         self.cameraMatrixes = None
    239         self.movingOffset = None