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

skillTreeMapView.py (7675B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\eve\client\script\ui\skillTree\skillTreeMapView.py
      2 from carbonui import uiconst
      3 from carbonui.primitives.container import Container
      4 from carbonui.util.color import Color
      5 from eve.client.script.ui import eveThemeColor
      6 from eve.client.script.ui.skillTree.skillTreeConst import ALL_GROUPS
      7 LINE_COLOR = eveThemeColor.THEME_FOCUS
      8 from eve.client.script.ui.shared.mapView import mapViewUtil
      9 from eve.client.script.ui.shared.mapView.mapView import MapView
     10 from eve.client.script.ui.skillTree.skillTreeDataProvider import GetSkillTreeDataProvider
     11 from eve.client.script.ui.skillTree.skillTreeBracket import SkillTreeBracket
     12 from eve.client.script.ui.skillTree.skillGroupSelectionCont import SkillGroupSelectionCont
     13 LINE_WIDTH = 3.0
     14 OPACITY_LINE_UNIMPORTANT = 0.05
     15 OPACITY_LINE_IDLE = 0.5
     16 OPACITY_LINE_HOVER = 1.0
     17 
     18 class SkillTreeMapView(MapView):
     19 
     20     def ApplyAttributes(self, attributes):
     21         super(SkillTreeMapView, self).ApplyAttributes(attributes)
     22         self.currCategoryID = None
     23         self.currGroupID = None
     24         self.skillTreeDataProvider = GetSkillTreeDataProvider()
     25         self.bracketsByTypeID = {}
     26         self.linesByTypeID = {}
     27         self.groupSelectionCont = SkillGroupSelectionCont(parent=self, align=uiconst.TOLEFT, width=300, idx=0)
     28         self.groupSelectionCont.onSkillGroupSelected.connect(self.OnSkillGroupSelected)
     29         self.bracketCont = Container(name='bracketCont', parent=self.infoLayer)
     30 
     31     def ConstructLineSet(self):
     32         self.lineSet = mapViewUtil.CreateLineSet()
     33         self.lineSet.name = 'SkillLines'
     34         self.scene.objects.append(self.lineSet)
     35 
     36     def OnSkillGroupSelected(self, groupID):
     37         self.RedrawTree(groupID)
     38 
     39     def _ConstructScene(self, interestID, zoomToItem):
     40         self.sceneContainer.Startup()
     41         self.camera.SetUpdateCallback(self.OnCameraUpdate)
     42         self.ConstructStarDataTexture()
     43         self.ConstructMapScene()
     44         self.ConstructLineSet()
     45         self.constructSceneThread = None
     46         self.camera.LookAtPoint((0, 0, 0))
     47         self.constructSceneThread = None
     48 
     49     def RedrawTree(self, groupID):
     50         self.currGroupID = groupID
     51         self.bracketCont.Flush()
     52         self.bracketsByTypeID = {}
     53         self.linesByTypeID = {}
     54         self.ConstructSkillNodes()
     55         self.ConstructLines()
     56 
     57     def ConstructSkillNodes(self):
     58         rootSkills = self.GetRootSkills()
     59         for i, skill in enumerate(rootSkills):
     60             self._ConstructSkillNodesRecursive(skill, 0, i, 0)
     61 
     62         for skill in rootSkills:
     63             bracket = self.bracketsByTypeID.get(skill.GetTypeID())
     64             bracket.UpdateBracketPosition()
     65 
     66     def _ConstructSkillNodesRecursive(self, skill, i, j, k, graphParent = None):
     67         if not self.NeedsConstructing(skill):
     68             return
     69         graphParent = self._ConstructSkillNode(skill, graphParent, i, j, k)
     70         k += 1
     71         children = self._GetChildrenForConstruction(skill)
     72         i = 0
     73         for child in children:
     74             if self.NeedsConstructing(child):
     75                 self._ConstructSkillNodesRecursive(child, i, j, k, graphParent=graphParent)
     76                 i += 1
     77 
     78     def _GetChildrenForConstruction(self, skill):
     79         children = skill.GetChildren()
     80         children = sorted(children, key=lambda node: sorted(node.GetDecendantsTypeIDs()))
     81         children = [ child for child in children if self.NeedsConstructing(child) ]
     82         return children
     83 
     84     def NeedsConstructing(self, child):
     85         return child.GetTypeID() not in self.bracketsByTypeID and self.IsInCurrentGroup(child)
     86 
     87     def _ConstructSkillNode(self, skill, graphParent, i, j, k):
     88         bracket = SkillTreeBracket(parent=self.bracketCont, curveSet=self.sceneContainer.bracketCurveSet, controller=skill, isInCurrGroup=self.IsInCurrentGroup(skill), currGroupID=self.currGroupID, onMouseEnter=self.OnNodeContMouseEnter, onMouseExit=self.OnNodeContMouseExit, idx=0)
     89         bracket.AddToGraph(graphParent, i, j, k)
     90         self.bracketsByTypeID[bracket.controller.GetTypeID()] = bracket
     91         return bracket
     92 
     93     def _GetSkillHorizontalSortKey(self, skill):
     94         numChildren = len([ child for child in skill.GetChildren() if self.IsInCurrentGroup(child) ])
     95         parentTypeIDs = sorted([ parent.GetTypeID() for parent in skill.GetParents() ])
     96         return (numChildren, parentTypeIDs)
     97 
     98     def IsInCurrentGroup(self, skill):
     99         return self.currGroupID in (ALL_GROUPS, skill.GetGroupID())
    100 
    101     def OnNodeContMouseExit(self, bracket):
    102         self._FadeAllLines(OPACITY_LINE_IDLE)
    103         for bracket in self.bracketsByTypeID.values():
    104             bracket.SetNormal()
    105 
    106     def OnNodeContMouseEnter(self, bracket):
    107         self._FadeAllLines(OPACITY_LINE_UNIMPORTANT)
    108         lineIDs = self._GetLineIDsForSubtree(bracket)
    109         for lineID in lineIDs:
    110             self._FadeLine(lineID, OPACITY_LINE_HOVER)
    111 
    112         self.lineSet.SubmitChanges()
    113         subtree = bracket.controller.GetSubtree()
    114         for b in self.bracketsByTypeID.values():
    115             if b.controller not in subtree:
    116                 b.SetDeemphasized()
    117             else:
    118                 b.SetEmphasized()
    119 
    120     def _GetLineIDsForSubtree(self, bracket):
    121         typeIDs = [ n.GetTypeID() for n in bracket.controller.GetSubtree() ]
    122         lines = set()
    123         for typeID1 in typeIDs:
    124             for typeID2 in typeIDs:
    125                 lineID = self.GetLineID(typeID1, typeID2)
    126                 if lineID is not None:
    127                     lines.add(lineID)
    128 
    129         return lines
    130 
    131     def _FadeAllLines(self, opacity):
    132         for lineID in self.GetAllLineIDs():
    133             self._FadeLine(lineID, opacity)
    134 
    135         self.lineSet.SubmitChanges()
    136 
    137     def _FadeLine(self, lineID, opacity):
    138         self.lineSet.ChangeLineColor(lineID, Color(*LINE_COLOR).SetOpacity(0.0).GetRGBA(), Color(*LINE_COLOR).SetOpacity(opacity).GetRGBA())
    139 
    140     def ConstructLines(self):
    141         self.lineSet.ClearLines()
    142         for nodeCont in self.bracketsByTypeID.values():
    143             for level, childNodes in nodeCont.controller.GetChildrenByLevel().iteritems():
    144                 for childNode in childNodes:
    145                     childNodeCont = self.bracketsByTypeID.get(childNode.GetTypeID(), None)
    146                     if not childNodeCont:
    147                         continue
    148                     self._ConstructLine(nodeCont, childNodeCont, level)
    149 
    150         self.lineSet.SubmitChanges()
    151 
    152     def _ConstructLine(self, parNodeCont, childNodeCont, level):
    153         startPos = parNodeCont.projectBracket.trackPosition
    154         endPos = childNodeCont.projectBracket.trackPosition
    155         lineID = self.lineSet.AddStraightLine(startPos, Color(*LINE_COLOR).SetOpacity(0.0).GetRGBA(), endPos, LINE_COLOR, LINE_WIDTH)
    156         childTypeID = childNodeCont.controller.GetTypeID()
    157         parTypeID = parNodeCont.controller.GetTypeID()
    158         self.linesByTypeID[tuple(sorted((childTypeID, parTypeID)))] = lineID
    159 
    160     def GetLineID(self, typeID1, typeID2):
    161         return self.linesByTypeID.get(tuple(sorted((typeID1, typeID2))), None)
    162 
    163     def GetAllLineIDs(self):
    164         return self.linesByTypeID.values()
    165 
    166     def GetRootSkills(self):
    167         if self.currGroupID == ALL_GROUPS:
    168             skills = self.skillTreeDataProvider.GetAllSkills()
    169             skills = sorted(skills, key=lambda node: node.IsRoot())
    170             return [ skill for skill in skills if skill.IsRoot() ]
    171         else:
    172             skills = self.skillTreeDataProvider.GetSkillsByGroupID(self.currGroupID)
    173             skills = sorted(skills, key=lambda node: node.IsRoot())
    174             return [ skill for skill in skills if skill.IsRootOfGroup() ]