def PlotDashLine(self):
dashSize = 2.0
gapSize = 7.0
r, g, b = self.GetRGB()
DASHCOLOR = (r, g, b, 1.0)
GAPCOLOR = (r, g, b, 0.0)
MARGIN = 16.0 * self.localScale
vecDir = geo2.Vec2Subtract(self.toPosition, self.fromPosition)
vecLength = geo2.Vec2Length(vecDir)
vecDirNorm = geo2.Vec2Normalize(vecDir)
p = MARGIN
while p < vecLength - MARGIN:
startPoint = geo2.Vec2Add(self.fromPosition,
geo2.Vec2Scale(vecDirNorm, p - 0.5))
self.AddPoint(startPoint, GAPCOLOR)
fromPoint = geo2.Vec2Add(self.fromPosition,
geo2.Vec2Scale(vecDirNorm, p))
self.AddPoint(fromPoint, DASHCOLOR)
p = min(vecLength - MARGIN, dashSize + p)
toPoint = geo2.Vec2Add(self.fromPosition,
geo2.Vec2Scale(vecDirNorm, p))
self.AddPoint(toPoint, DASHCOLOR)
endPoint = geo2.Vec2Add(self.fromPosition,
geo2.Vec2Scale(vecDirNorm, p + 0.5))
self.AddPoint(endPoint, GAPCOLOR)
p += gapSize
def ApplyLineMargin(self, p1, p2, radius1, radius2):
v = geo2.Vec2Subtract(p1, p2)
vn = geo2.Vec2Normalize(v)
l = geo2.Vec2Length(v)
if not l:
return (None, None)
s = (radius1 + radius2) / l
mp1 = geo2.Vec2Subtract(p1, geo2.Vec2Scale(vn, radius1))
mp2 = geo2.Vec2Add(p2, geo2.Vec2Scale(vn, radius2))
return (mp1, mp2)
def PlotLineTrace(self):
self.Flush()
if self.glowLine:
self.glowLine.Flush()
if self.lineType in (LINE_DASHED, LINE_DASHED_ACTIVE):
self.PlotDashLine()
elif self.lineType == LINE_SOLID:
self.PlotSolidLine()
else:
return
if self.lineType == LINE_DASHED_ACTIVE:
vecDir = geo2.Vec2Subtract(self.toPosition, self.fromPosition)
vecLength = geo2.Vec2Length(vecDir)
vecDirNorm = geo2.Vec2Normalize(vecDir)
r, g, b = self.GetRGB()
GLOWCOLOR = (r, g, b, 1.0)
GAPCOLOR = (r, g, b, 0.0)
self.glowLine.AddPoint(self.fromPosition, GAPCOLOR)
point = geo2.Vec2Add(self.fromPosition,
geo2.Vec2Scale(vecDirNorm, vecLength * 0.5))
self.glowLine.AddPoint(point, GLOWCOLOR)
self.glowLine.AddPoint(self.toPosition, GAPCOLOR)
self.glowLine.textureWidth = vecLength
uicore.animations.MorphScalar(self.glowLine,
'textureOffset',
startVal=0.0,
endVal=1.0,
curveType=uiconst.ANIM_LINEAR,
duration=2.0,
loops=uiconst.ANIM_REPEAT)
def IsMouseHeadingTowards(self):
owner = self.GetOwner()
if owner.destroyed:
return False
mx, my = uicore.ScaleDpi(uicore.uilib.x), uicore.ScaleDpi(
uicore.uilib.y)
if len(self._mouseTrace) > SAMPLESIZE:
self._mouseTrace.pop(0)
self._mouseTrace.append((mx, my))
tl, tt, tw, th = (owner.displayX, owner.displayY, owner.displayWidth,
owner.displayHeight)
if tl <= mx <= tl + tw and tt <= my <= tt + th:
return False
oldX, oldY = self._mouseTrace[0]
if (oldX, oldY) == (mx, my):
return False
mouseVector = geo2.Vec2Subtract((oldX, oldY), (mx, my))
dirX, dirY = geo2.Vec2Scale(mouseVector, 1000)
hit = intersect((tl, tt), (tl + tw, tt + th), (mx, my),
(mx - dirX, my - dirY))
if not hit:
hit = intersect((tl + tw, tt), (tl, tt + th), (mx, my),
(mx - dirX, my - dirY))
if hit:
return True
return False
def UpdateState(self):
tileFromData = self.tileFrom.tileData
tileToData = self.tileTo.tileData
if not tileFromData.IsFlippable() and not tileToData.IsFlippable():
colorFrom = colorTo = hackingUIConst.COLOR_BLOCKED
elif hackingConst.TYPE_NONE in (tileFromData.type, tileToData.type):
colorFrom = colorTo = hackingUIConst.COLOR_UNEXPLORED
else:
colorFrom = colorTo = hackingUIConst.COLOR_EXPLORED
self.ShowBleed()
widthFrom = widthTo = hackingUIConst.WIDTH_LINE
if tileFromData.blocked or tileFromData.type == hackingConst.TYPE_DEFENSESOFTWARE:
colorFrom = (0.0, 0.0, 0.0, 0.5)
widthFrom = 5.0
if not (tileToData.blocked
or tileToData.type == hackingConst.TYPE_DEFENSESOFTWARE):
widthTo = 0.0
if tileToData.blocked or tileToData.type == hackingConst.TYPE_DEFENSESOFTWARE:
colorFrom = (0.0, 0.0, 0.0, 0.5)
widthTo = 5.0
if not (tileFromData.blocked
or tileFromData.type == hackingConst.TYPE_DEFENSESOFTWARE):
widthFrom = 0.0
uicore.animations.SpColorMorphTo(self.line,
self.line.colorFrom,
colorFrom,
attrName='colorFrom')
uicore.animations.SpColorMorphTo(self.line,
self.line.colorTo,
colorFrom,
attrName='colorTo')
uicore.animations.MorphScalar(self.line, 'widthFrom',
self.line.widthFrom, widthFrom)
uicore.animations.MorphScalar(self.line, 'widthTo', self.line.widthTo,
widthTo)
offset1 = self.GetLineOffsetAmount(self.tileFrom.tileData.type)
p0 = geo2.Vec2Add(self.p0, geo2.Vec2Scale(self.offset, offset1))
self.line.translationFrom = p0
offset2 = self.GetLineOffsetAmount(self.tileTo.tileData.type)
p1 = geo2.Vec2Subtract(self.p1, geo2.Vec2Scale(self.offset, offset2))
self.line.translationTo = p1
def PlotSolidLine(self):
r, g, b = self.GetRGB()
DASHCOLOR = (r, g, b, 1.0)
GAPCOLOR = (r, g, b, 0.0)
MARGIN = 16.0 * self.localScale
vecDir = geo2.Vec2Subtract(self.toPosition, self.fromPosition)
vecLength = geo2.Vec2Length(vecDir)
vecDirNorm = geo2.Vec2Normalize(vecDir)
startPoint = geo2.Vec2Add(self.fromPosition,
geo2.Vec2Scale(vecDirNorm, MARGIN))
self.AddPoint(startPoint, GAPCOLOR)
startPoint = geo2.Vec2Add(self.fromPosition,
geo2.Vec2Scale(vecDirNorm, MARGIN + 8))
self.AddPoint(startPoint, DASHCOLOR)
startPoint = geo2.Vec2Add(
self.fromPosition,
geo2.Vec2Scale(vecDirNorm, vecLength - MARGIN - 8))
self.AddPoint(startPoint, DASHCOLOR)
startPoint = geo2.Vec2Add(
self.fromPosition, geo2.Vec2Scale(vecDirNorm, vecLength - MARGIN))
self.AddPoint(startPoint, GAPCOLOR)
def seg_intersect(line1, line2):
a1, a2 = line1
b1, b2 = line2
da = geo2.Vec2Subtract(a2, a1)
db = geo2.Vec2Subtract(b2, b1)
dp = geo2.Vec2Subtract(a1, b1)
dap = (-da[1], da[0])
denom = geo2.Vec2Dot(dap, db)
if not denom:
return False
num = geo2.Vec2Dot(dap, dp)
return geo2.Vec2Scale(geo2.Vec2Add(db, b1), num / denom)
def closest_point_on_seg(seg_a, seg_b, circ_pos):
seg_v = geo2.Vec2Subtract(seg_b, seg_a)
pt_v = geo2.Vec2Subtract(circ_pos, seg_a)
if geo2.Vec2Length(seg_v) <= 0:
raise ValueError, 'Invalid segment length'
seg_v_unit = geo2.Vec2Normalize(seg_v)
proj = geo2.Vec2Dot(seg_v_unit, pt_v)
if proj <= 0:
return seg_a
if proj >= geo2.Vec2Length(seg_v):
return seg_b
proj_v = geo2.Vec2Scale(seg_v_unit, proj)
closest = geo2.Vec2Add(proj_v, seg_a)
return closest
def GetVectorBetweenObjectsOnSameLevel(self,
fromObjectID,
toObjectID,
parentObjectID,
i=0):
plotData = GetPlotDataForObject(parentObjectID, ignoreFixed=False)
if fromObjectID in plotData:
column1, row1 = plotData[fromObjectID]
fromPos = hexUtil.hex_slot_center_position(column1, row1,
self.isFlatTop,
self.hexGridSize)
elif self.parentMap and fromObjectID in self.parentMap.markersByID:
fromPos = self.parentMap.markersByID[fromObjectID].unscaledPosition
else:
return
if toObjectID in plotData:
column2, row2 = plotData[toObjectID]
toPos = hexUtil.hex_slot_center_position(column2, row2,
self.isFlatTop,
self.hexGridSize)
elif self.parentMap and toObjectID in self.parentMap.markersByID:
toPos = self.parentMap.markersByID[toObjectID].unscaledPosition
else:
return
diffVec = geo2.Vec2Subtract(toPos, fromPos)
diffVec = geo2.Vec2Scale(diffVec, 100000000000.0)
cornerPoints = []
for i in xrange(6):
if self.isFlatTop:
outlineRad = self.width * 0.5
angle = 2.0 * math.pi / 6.0 * i
else:
outlineRad = self.height * 0.5
angle = 2.0 * math.pi / 6.0 * (i + 0.5)
x_i = outlineRad * math.cos(angle)
y_i = outlineRad * math.sin(angle)
cornerPoints.append((x_i, y_i))
for i in xrange(6):
p1 = cornerPoints[i]
p2 = cornerPoints[i - 1]
crossPoint = hexUtil.intersect_line_segments((p1, p2),
((0.0, 0.0), diffVec))
if crossPoint:
return crossPoint
def _PanUpdateThread(self):
while True:
if self.panTarget is None or not self.mainCont.children:
break
distLeft = geo2.Vec2Length(self.panTarget)
if distLeft == 0:
break
dist = self.panSpeed / blue.os.fps
if distLeft < 1.0:
dist *= 1.0 / distLeft
dist = min(dist, 1.0)
toMove = geo2.Vec2Scale(self.panTarget, dist)
self.panTarget -= toMove
dx, dy = toMove
self.panLeft -= dx / self.mainCont.width
self.panTop -= dy / self.mainCont.height
blue.synchro.Yield()
self.panUpdateThread = None
self.panTarget = None
def _GetNodePosition(self, node):
vec = geo2.Vec2Subtract(node.GetPosition(), self._offset)
return geo2.Vec2Scale(vec, TREE_SCALE)
def _GetNodePosition(self, node):
""" Returns node position scaled and offset so that the bottom-left most point is at (0, 0) """
vec = geo2.Vec2Subtract(node.GetPosition(), self._offset)
return geo2.Vec2Scale(vec, TREE_SCALE)