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

ballparks.py (9562B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\behaviors\conditions\ballparks.py
      2 import logging
      3 import geo2
      4 from ballpark.const import DESTINY_MODE_ORBIT
      5 from ballpark.warpDisruptionBalls import GetWarpBubbleItemIdsWithinRangeOfCoordinate
      6 from behaviors import status
      7 from behaviors.tasks import Task
      8 from behaviors.utility.ballparks import is_ball_cloaked, get_my_position, is_ball_in_park, get_ball
      9 from ccpProfile import TimedFunction
     10 from eve.common.lib.appConst import shipNotWarping, minWarpDistance
     11 from eveexceptions import UserError
     12 logger = logging.getLogger(__name__)
     13 
     14 class IsCoordinateInSameBubbleCondition(Task):
     15 
     16     @TimedFunction('behaviors::conditions::ballparks::IsCoordinateInSameBubbleCondition::OnEnter')
     17     def OnEnter(self):
     18         coordinates = self.GetLastBlackboardValue(self.attributes.coordinateAddress)
     19         returnStatus = status.TaskFailureStatus
     20         if coordinates is not None:
     21             bubbleID = self.context.ballpark.GetBubbleAtCoordinates(*coordinates)
     22             if bubbleID == self.context.myBall.newBubbleId:
     23                 returnStatus = status.TaskSuccessStatus
     24         self.status = returnStatus
     25 
     26 
     27 class IsCoordinateWithinDistance(Task):
     28 
     29     @TimedFunction('behaviors::conditions::ballparks::IsCoordinateWithinDistance::OnEnter')
     30     def OnEnter(self):
     31         coordinates = self.GetLastBlackboardValue(self.attributes.coordinateAddress)
     32         self.SetStatusToFailed()
     33         if coordinates is not None:
     34             myBall = self.context.myBall
     35             myCoordinates = (myBall.x, myBall.y, myBall.z)
     36             vecToCoord = geo2.Vec3SubtractD(coordinates, myCoordinates)
     37             distance = geo2.Vec3Length(vecToCoord)
     38             self.SetStatusToSuccessIfTrueElseToFailed(distance <= self.GetMaxDistance())
     39 
     40     def GetMaxDistance(self):
     41         return self.attributes.maxDistance
     42 
     43 
     44 class IsCoordinateWithinDistanceByAddress(IsCoordinateWithinDistance):
     45 
     46     def GetMaxDistance(self):
     47         maxDistance = self.GetLastBlackboardValue(self.attributes.maxDistanceAddress)
     48         if self.HasAttribute('fudgeDistanceAddress'):
     49             fudgeDistance = self.GetLastBlackboardValue(self.attributes.fudgeDistanceAddress)
     50             if fudgeDistance is not None:
     51                 maxDistance += self.GetLastBlackboardValue(self.attributes.fudgeDistanceAddress)
     52         return maxDistance
     53 
     54 
     55 class IsBallPresentInMyBubbleCondition(Task):
     56 
     57     def OnEnter(self):
     58         ballId = self.GetLastBlackboardValue(self.attributes.ballIdAddress)
     59         ball = self.context.ballpark.balls.get(ballId)
     60         if ball and ball.newBubbleId == self.context.myBall.newBubbleId:
     61             self.SetStatusToSuccess()
     62         else:
     63             self.SetStatusToFailed()
     64 
     65 
     66 class IsBallPresentInBubbleByAddress(Task):
     67 
     68     def OnEnter(self):
     69         bubbleId = self.GetLastBlackboardValue(self.attributes.bubbleIdAddress)
     70         ballId = self.GetLastBlackboardValue(self.attributes.ballIdAddress)
     71         ball = self.context.ballpark.balls.get(ballId)
     72         if ball and ball.newBubbleId == bubbleId:
     73             self.SetStatusToSuccess()
     74         else:
     75             self.SetStatusToFailed()
     76 
     77 
     78 class IsBallWithInDistanceCondition(Task):
     79 
     80     @TimedFunction('behaviors::conditions::ballparks::IsBallWithInDistanceCondition::OnEnter')
     81     def OnEnter(self):
     82         self.SetStatusToFailed()
     83         ballId = self.GetLastBlackboardValue(self.attributes.ballIdAddress)
     84         source_ball_id = self._get_source_ball_id()
     85         distance = self.context.ballpark.GetSurfaceDist(source_ball_id, ballId)
     86         if distance <= self.attributes.maxDistance:
     87             self.SetStatusToSuccess()
     88 
     89     def _get_source_ball_id(self):
     90         return self.context.myItemId
     91 
     92 
     93 class IsBallWithinDistanceOfBallCondition(IsBallWithInDistanceCondition):
     94 
     95     def _get_source_ball_id(self):
     96         return self.GetLastBlackboardValue(self.attributes.sourceBallIdAddress)
     97 
     98 
     99 class AreItemsWithInDistanceCondition(Task):
    100 
    101     def OnEnter(self):
    102         self.SetStatusToFailed()
    103         itemId = self.GetLastBlackboardValue(self.attributes.itemIdAddress)
    104         otherItemIdAddress = getattr(self.attributes, 'otherItemIdAddress', None)
    105         if otherItemIdAddress is None:
    106             otherItemId = self.context.myItemId
    107         else:
    108             otherItemId = self.GetLastBlackboardValue(self.attributes.otherItemIdAddress)
    109         distance = self.context.ballpark.GetSurfaceDist(itemId, otherItemId)
    110         maxDistance = self.GetLastBlackboardValue(self.attributes.maxDistanceAddress)
    111         maxDistanceMultiplier = getattr(self.attributes, 'maxDistanceMultiplier', None) or 1.0
    112         maxDistance *= maxDistanceMultiplier
    113         if distance <= maxDistance:
    114             self.SetStatusToSuccess()
    115 
    116 
    117 class IsOrbitingTargetCondition(Task):
    118 
    119     def IsOrbitingTarget(self, targetId):
    120         if targetId is None:
    121             return False
    122         if self.context.myBall.mode != DESTINY_MODE_ORBIT:
    123             return False
    124         if self.context.myBall.followId != targetId:
    125             return False
    126         return True
    127 
    128     @TimedFunction('behaviors::conditions::ballparks::IsOrbitingTargetCondition::OnEnter')
    129     def OnEnter(self):
    130         targetId = self.GetLastBlackboardValue(self.attributes.targetAddress)
    131         isOrbitingTarget = self.IsOrbitingTarget(targetId)
    132         if isOrbitingTarget:
    133             self.status = status.TaskSuccessStatus
    134         else:
    135             self.status = status.TaskFailureStatus
    136 
    137 
    138 class IsBallCloakedCondition(Task):
    139 
    140     @TimedFunction('behaviors::conditions::ballparks::IsBallCloakedCondition::OnEnter')
    141     def OnEnter(self):
    142         ballId = self.GetLastBlackboardValue(self.attributes.ballIdAddress)
    143         isCloaked = is_ball_cloaked(self, ballId)
    144         if isCloaked:
    145             self.status = status.TaskSuccessStatus
    146         else:
    147             self.status = status.TaskFailureStatus
    148 
    149 
    150 class IsBallInWarpCondition(Task):
    151 
    152     @TimedFunction('behaviors::conditions::ballparks::IsBallInWarpCondition::OnEnter')
    153     def OnEnter(self):
    154         self.SetStatusToFailed()
    155         ballId = self.GetLastBlackboardValue(self.attributes.ballIdAddress)
    156         try:
    157             warpState = self.context.ballpark.IsWarping(ballId)
    158             if warpState != shipNotWarping:
    159                 self.SetStatusToSuccess()
    160         except UserError:
    161             pass
    162 
    163 
    164 class IsLocationWithinWarpDistance(Task):
    165 
    166     @TimedFunction('behaviors::conditions::ballparks::IsBallWithinWarpDistance::OnEnter')
    167     def OnEnter(self):
    168         self.SetStatusToFailed()
    169         targetCoordinates = self.GetLastBlackboardValue(self.attributes.coordinateAddress)
    170         if targetCoordinates:
    171             myCoordinates = (self.context.myBall.x, self.context.myBall.y, self.context.myBall.z)
    172             distance = geo2.Vec3DistanceD(targetCoordinates, myCoordinates)
    173             if distance > minWarpDistance:
    174                 self.SetStatusToSuccess()
    175 
    176 
    177 class IsBallWithinWarpDistance(Task):
    178 
    179     @TimedFunction('behaviors::conditions::ballparks::IsBallWithinWarpDistance::OnEnter')
    180     def OnEnter(self):
    181         self.SetStatusToFailed()
    182         target_ball_id = self.GetLastBlackboardValue(self.attributes.ballIdAddress)
    183         if not is_ball_in_park(self, target_ball_id):
    184             return
    185         distance = self.context.ballpark.GetSurfaceDist(target_ball_id, self.context.myBall.id)
    186         if distance > minWarpDistance:
    187             self.SetStatusToSuccess()
    188 
    189 
    190 class HasValidBallTarget(Task):
    191 
    192     @TimedFunction('behaviors::conditions::ballparks::HasValidBallTarget::OnEnter')
    193     def OnEnter(self):
    194         self.SetStatusToFailed()
    195         hasBall = self.context.ballpark.HasBall(self.GetLastBlackboardValue(self.attributes.ballIdAddress))
    196         if hasBall:
    197             self.SetStatusToSuccess()
    198 
    199 
    200 class IsPathToCoordinatesClearOfBubbles(Task):
    201 
    202     @TimedFunction('behaviors::conditions::ballparks::IsPathToCoordinatesClearOfBubbles::OnEnter')
    203     def OnEnter(self):
    204         self.SetStatusToFailed()
    205         coordinates = self._get_my_warp_to_coordinates()
    206         if coordinates is None:
    207             return
    208         if self._is_path_to_coordinates_clear(coordinates):
    209             self.SetStatusToSuccess()
    210 
    211     def _get_my_warp_to_coordinates(self):
    212         return self.GetLastBlackboardValue(self.attributes.coordinateAddress)
    213 
    214     def _is_path_to_coordinates_clear(self, coordinates):
    215         try:
    216             warp_disruptor_id, _ = self._get_closest_warp_disruptor_and_intersection_in_path(coordinates)
    217         except UserError:
    218             logger.debug('Behavior=%s for entity=%s warp path blocked by bubble that is too close to entity for warping there', self.behaviorTree.GetBehaviorId(), self.context.myItemId)
    219             return False
    220 
    221         if warp_disruptor_id is None:
    222             return True
    223         return self._is_warp_disruptor_at_end_coordinate(warp_disruptor_id, coordinates)
    224 
    225     def _get_closest_warp_disruptor_and_intersection_in_path(self, coordinates):
    226         return self.context.ballpark.GetClosestDisruptorAndIntersectionInWarpPath(get_my_position(self), coordinates)
    227 
    228     def _is_warp_disruptor_at_end_coordinate(self, warp_disruptor_id, coordinates):
    229         warp_disruption_probe_ids, warp_disruption_ship_ids = self._get_warp_bubble_ids_at_coordinates(coordinates)
    230         return warp_disruptor_id in warp_disruption_probe_ids or warp_disruptor_id in warp_disruption_ship_ids
    231 
    232     def _get_warp_bubble_ids_at_coordinates(self, coordinates):
    233         return GetWarpBubbleItemIdsWithinRangeOfCoordinate(self.context.ballpark, coordinates)