def __init__(self):
BE_Object.__init__(self)
self._type = self.CANVASOBJECT_FLANK
self.year = 0
self.standDistance = None
self.origin = Geometry.Point2D()
self.target = Geometry.Point2D()
self.battalions = {}
self.battalions['Infantry'] = {
'Number': None,
'BattalionSize': None,
'GroupSize': None,
'GroupDistance': None
}
self.battalions['Archers'] = {
'Number': None,
'BattalionSize': None,
'GroupSize': None,
'GroupDistance': None
}
self.battalions['Cannons'] = {
'Number': None,
'BattalionSize': None,
'GroupSize': None,
'GroupDistance': None
}
self.battalions['SiegeTowers'] = {
'Number': None,
'BattalionSize': None,
'GroupSize': None,
'GroupDistance': None
}
def __init__(self):
BE_Object.__init__(self)
self._type = self.CANVASOBJECT_CITYEVOLUTION
self.timeRange = [0, 0]
self.baseSegment = Geometry.Segment2D()
self.arrow = Geometry.Segment2D()
self.housesPerYear = 1
self.groupID = 0
self.__colorDB = wx.ColourDatabase()
def __init__(self, mainwindow):
BE_HandlerCanvas.__init__(self, mainwindow)
self.__extraStatus = self.STATUS_EXT_NONE
self.__baseSegment = Geometry.Segment2D()
self.__arrowEndPoint = Geometry.Point2D()
self.__XORflag = False # internal flag to control the draw xor issues for the first arrow drawing time
def Draw(self, dc):
if (self._status == self.STATUS_FINISHED):
return
if (self._status == self.STATUS_NOTSTARTED):
return
canvas = self.GetCanvas()
lastpen = dc.GetPen()
if (self._status == self.STATUS_STARTED):
if (self._prevMousePos and self._curMousePos):
dc.SetPen(wx.Pen(wx.Colour(0, 0, 0, wx.ALPHA_OPAQUE), 2))
dc.SetLogicalFunction(wx.INVERT)
start = canvas.UserToScreenCoord(self.__startPos.x,
self.__startPos.y)
prev = canvas.UserToScreenCoord(self._prevMousePos.x,
self._prevMousePos.y)
curr = canvas.UserToScreenCoord(self._curMousePos.x,
self._curMousePos.y)
dc.DrawLine(start.x, start.y, prev.x, prev.y)
if (self.__XORflag):
seg = Geometry.Segment2D(self.__startPos,
self._prevMousePos)
arrow = seg.GetArrow(atEnd=True, size=30, arrowangle=20)
plist = []
for p in arrow:
parrow = canvas.UserToScreenCoord(p.x, p.y)
plist.append([parrow.x, parrow.y])
dc.DrawPolygon(plist)
self.__XORflag = True
dc.DrawLine(start.x, start.y, curr.x, curr.y)
seg = Geometry.Segment2D(self.__startPos, self._curMousePos)
arrow = seg.GetArrow(atEnd=True, size=30, arrowangle=20)
plist = []
for p in arrow:
parrow = canvas.UserToScreenCoord(p.x, p.y)
plist.append([parrow.x, parrow.y])
dc.DrawPolygon(plist)
dc.SetPen(lastpen)
def GetBoundingBox(self):
bbox = Geometry.BoundingQuad()
p = self.center.Copy()
p.Move(Geometry.Vector2D(-1, -1), self.__size / 2.0)
bbox.InsertPoint(p)
p = self.center.Copy()
p.Move(Geometry.Vector2D(-1, 1), self.__size / 2.0)
bbox.InsertPoint(p)
p = self.center.Copy()
p.Move(Geometry.Vector2D(1, -1), self.__size / 2.0)
bbox.InsertPoint(p)
p = self.center.Copy()
p.Move(Geometry.Vector2D(1, 1), self.__size / 2.0)
bbox.InsertPoint(p)
return bbox
def ScreenToUserCoord(self, x, y):
# See at header for more information
scale = [
float(self.__viewportSize[0]) / float(self.__windowSize[0]),
float(self.__viewportSize[0]) / float(self.__windowSize[0])
]
return Geometry.Point2D(x * scale[0], y * scale[1])
def GetBoundingBox(self):
bbox = Geometry.BoundingQuad()
bbox.InsertPoint(self.baseSegment.p1)
bbox.InsertPoint(self.baseSegment.p2)
bbox.InsertPoint(self.arrow.p2)
return bbox
def GetBoundingBox(self):
bbox = Geometry.BoundingQuad()
for p in self.__polyline:
bbox.InsertPoint(p)
bbox.Expand(self.__width)
return bbox
def Select(self, point):
# Since river is a nonclosed polyline, we need to check the selection over each polyline segment
i = 1
while (i < len(self.__polyline)):
seg = Geometry.Segment2D(self.__polyline[i - 1],
self.__polyline[i])
poly = seg.GetBounding(self.__width / 2.0)
bbox = Geometry.BoundingQuad()
for p in poly.shape:
bbox.InsertPoint(p.p1)
if (len(poly.shape) > 0):
bbox.InsertPoint(poly.shape[-1].p2)
if (bbox.IsInside(point)):
return True
i += 1
return False
def GetBoundingBox(self):
# TODO: Improve bounding over arrow (not box)
bbox = Geometry.BoundingQuad()
bbox.InsertPoint(self.origin)
bbox.InsertPoint(self.target)
bbox.Expand(20)
return bbox
def GetBoundingBox(self):
bbox = Geometry.BoundingQuad()
for p in self.__shape:
bbox.InsertPoint(p)
for p in self.__shape:
if (p.data):
bbox.Expand(p.data.size)
break
return bbox
def Draw(self, dc, document, canvas):
towerdata = document.GetDefaultSettings().castle.towers
self.size = towerdata.squareSide / 2.0
lastpen = dc.GetPen()
dc.SetPen(wx.Pen(wx.Colour(100, 100, 100, wx.ALPHA_OPAQUE), 1))
if (self.__towertype == self.TOWERTYPE_SQUARED):
center = self.__center.Copy()
center.Move(Geometry.Vector2D(-1, -1), towerdata.squareSide / 2.0)
center = canvas.UserToScreenCoord(center.x, center.y)
side = canvas.UserToScreenValue(
towerdata.squareSide
) # NOTE: This sould be changed if window/viewport are not squared
dc.DrawRectangle(center.x, center.y, side, side)
if (self.__towertype == self.TOWERTYPE_ROUNDED):
center = self.__center.Copy()
center.Move(Geometry.Vector2D(-1, -1),
towerdata.circleRadius / 2.0)
center = canvas.UserToScreenCoord(center.x, center.y)
radius = canvas.UserToScreenValue(
towerdata.circleRadius
) # NOTE: This sould be changed if window/viewport are not squared
dc.DrawEllipse(center.x, center.y, radius * 2, radius * 2)
if (self.__towertype == self.TOWERTYPE_RANDOM):
lastfont = dc.GetFont()
currfont = wx.Font(pointSize=25,
family=wx.FONTFAMILY_DEFAULT,
style=wx.FONTSTYLE_NORMAL,
weight=wx.FONTWEIGHT_BOLD)
dc.SetFont(currfont)
center = canvas.UserToScreenCoord(self.__center.x, self.__center.y)
dc.DrawText("?", center.x, center.y)
dc.SetFont(lastfont)
dc.SetPen(lastpen)
def Draw(self, dc, document, canvas):
battle = document.GetGameData().battles.GetBattle(self.year)
if (not battle):
return
if (not battle.color):
return
lastpen = dc.GetPen()
lastbrush = dc.GetBrush()
dc.SetPen(wx.Pen(battle.color, 1))
dc.SetBrush(wx.Brush(battle.color, wx.BDIAGONAL_HATCH))
plist = []
axis = Geometry.Segment2D(self.origin, self.target)
length = axis.GetLength()
direction = axis.GetDirection()
normal = axis.GetNormal()
arrowwidth = 20
arrowcapheight = 50
arrowcapwidth = 50
p = self.origin.Copy()
p.Move(normal, arrowwidth / 2.0)
plist.append([p.x, p.y])
p.Move(direction, length - arrowcapheight)
plist.append([p.x, p.y])
p.Move(normal, (arrowcapwidth / 2.0) - (arrowwidth / 2.0))
plist.append([p.x, p.y])
plist.append([self.target.x, self.target.y])
p.Move(normal, -arrowcapwidth)
plist.append([p.x, p.y])
p.Move(normal, (arrowcapwidth / 2.0) - (arrowwidth / 2.0))
plist.append([p.x, p.y])
p = self.origin.Copy()
p.Move(normal, -arrowwidth / 2.0)
plist.append([p.x, p.y])
plistcanvas = []
for pl in plist:
pc = canvas.UserToScreenCoord(pl[0], pl[1])
plistcanvas.append([pc.x, pc.y])
dc.DrawPolygon(plistcanvas)
dc.SetBrush(lastbrush)
dc.SetPen(lastpen)
def defineTarget(data):
# Start the simulation
angle = 270.
newPos = initCircularPoint(angle)
global showGraphics
showGraphics = True
detailedResults = doBattle(newPos, data)
showGraphics = False
newDist = 0
newBreach = None
for r in detailedResults:
# newDist = comparePositions(targetPos, getClimbingPos(r))
newBreach = getClimbingPos(r)
# targetPos = geom.Point2D(153, 234) #this is the result from angle 270
targetPos = geom.Point2D(newBreach.x, newBreach.y)
print "Objective:", newBreach.x, newBreach.y, newBreach.z
print "From:", angle, "=>", [newPos[0], newPos[1]]
pointsToShow.extend([[newPos[0], newPos[1], 'G', 'red'],
[newBreach.x, newBreach.y, 'W', 'red']
])
return targetPos
def Draw(self, dc, document, canvas):
citydata = document.GetDefaultSettings().city
self.__size = citydata.housesSize
lastpen = dc.GetPen()
lastbrush = dc.GetBrush()
dc.SetPen(wx.Pen(wx.Colour(141, 114, 71, wx.ALPHA_OPAQUE), 1))
dc.SetBrush(wx.Brush(wx.Colour(234, 207, 160), wx.SOLID))
p = self.center.Copy()
p.Move(Geometry.Vector2D(-1, -1), citydata.housesSize / 2.0)
p = canvas.UserToScreenCoord(p.x, p.y)
size = canvas.UserToScreenValue(
citydata.housesSize
) # NOTE: This sould be changed if window/viewport are not squared. A polygon should be calculated instead
dc.DrawRectangle(p.x, p.y, size, size)
dc.SetBrush(lastbrush)
dc.SetPen(lastpen)
def ImportXML(self, root, document):
main = root.find("Battlefield")
if (not main):
return
try:
self.__bounding = int(main.find("Bounding").text)
except:
pass
try:
self.__cellsize = int(main.find("CellSize").text)
except:
pass
rivers = main.find("Rivers")
if (rivers):
for trace in rivers:
try:
if (trace.tag == "Trace"):
width = float(trace.find("Width").text)
pol = []
polyline = trace.find("Polyline")
if (polyline):
for v in polyline:
if (v.tag == "Vertex"):
array = ast.literal_eval(v.text)
pol.append(
Geometry.Point2D(array[0], array[1]))
river = BE_Objects.BE_River()
river.SetShape(pol, width)
document.AddCanvasObject(river)
except:
print "WARNING: Wrong river data"
def ImportXML(self, root, document):
main = root.find("BattleEvents")
if (not main):
return
for battlexml in main:
if (battlexml.tag == "Battle"):
battle = BE_BattleData()
try:
battle.year = int(battlexml.find("Year").text)
except:
print "ERROR: Battle year not specified in a battle of the BattleEvents category"
continue
try:
battle.nSimulations = int(
battlexml.find("Simulations").text)
except:
print "WARNING: Wrong battle simulations number in a battle of the BattleEvents category"
try:
battle.repeatUntil = (
battlexml.find("RepeatUntilDefendersWin").text
in ['True', 'true', 'yes', 'YES', '1', 'Yes', 'TRUE'])
except:
print "WARNING: RepeatUntilDefendersWin tag not found in a battle of the BattleEvents category"
# Defenders
defendersxml = battlexml.find("Defenders")
if (defendersxml != None):
try:
archersxml = defendersxml.find("Archers")
if (archersxml != None):
battle.defenders['Archers'] = int(archersxml.text)
else:
battle.defenders['Archers'] = 0
cannonsxml = defendersxml.find("Cannons")
if (cannonsxml != None):
battle.defenders['Cannons'] = int(cannonsxml.text)
else:
battle.defenders['Cannons'] = 0
except:
print "WARNING: Wrong defenders data in a battle of the BattleEvents category"
else:
print "WARNING: None defenders has been specified in a battle of the BattleEvents category"
# Attackers
attackersxml = battlexml.find("Attackers")
if (attackersxml != None):
# Flanks
for flankxml in attackersxml:
if (flankxml.tag == "Flank"):
flank = BE_Objects.BE_Flank()
flank.year = battle.year
try:
dist = flankxml.find("StandDistance")
if (dist != None):
flank.standDistance = float(
dist.text) # Optional
# TODO: Place the arrow flank considering the standdistance
dirxml = ast.literal_eval(
flankxml.find("Direction").text)
direction = Geometry.Vector2D(
float(dirxml[0]), float(dirxml[1]))
direction.Normalize()
originxml = flankxml.find("origin")
if (originxml != None):
origin = ast.literal_eval(originxml.text)
flank.origin = Geometry.Point2D(
float(origin[0]), float(origin[1]))
else:
# Directional flank (no origin)
# Place the arrow at the viewport edges
viewsize = document.GetDefaultSettings(
).game.viewportSize
origin = Geometry.Point2D(
viewsize / 2.0, viewsize / 2.0)
origin.Move(direction.Copy().Invert(),
viewsize / 2.0)
flank.origin = origin.Copy()
# TODO : Improve this to work with standdistance
# Since arrow length is not used in the simulation, it could not be found in the incoming xml (except it is created by the editor, see ExportXML)
# If it is not present, use a default value
arrowlengthxml = flankxml.find(
"BE_Editor_ArrowLength")
if (arrowlengthxml == None):
arrowlength = 200.0
else:
arrowlength = float(arrowlengthxml.text)
flank.target = flank.origin.Copy()
flank.target.Move(direction, arrowlength)
except:
print "WARNING: Wrong flank data of a battle in BattleEvents category"
# Flank battalions
battalionsxml = flankxml.find("Battalions")
if (battalionsxml != None):
for battalionxml in battalionsxml:
try:
type = battalionxml.find("Type").text
number = int(
battalionxml.find("Number").text)
batsizexml = battalionxml.find(
"BattalionSize")
if (batsizexml != None):
battalionsize = int(
batsizexml.text)
else:
battalionsize = None
groupsizexml = battalionxml.find(
"GroupSize")
if (groupsizexml != None):
groupsize = int(groupsizexml.text)
else:
groupsize = None
groupdistxml = battalionxml.find(
"GroupDistance")
if (groupdistxml != None):
groupdist = int(groupdistxml.text)
else:
groupdist = None
flank.battalions[type] = {
'Number': number,
'BattalionSize': battalionsize,
'GroupSize': groupsize,
'GroupDistance': groupdist
}
except:
print "WARNING: Wrong battalion data in a flank of the BattleEvents category"
else:
print "WARNING: None battalion has found in a flank of the BattleEvents category"
battle.flanks.append(flank)
document.AddCanvasObject(flank)
else:
print "WARNING: None attackers has been specified in a battla of the BattleEvents category"
battle.SetColor()
self.__battles[battle.year] = battle
def ExportXML(self, root, document):
main = ET.SubElement(root, "BattleEvents")
for k, v in self.__battles.items():
battlexml = ET.SubElement(main, "Battle")
ET.SubElement(battlexml, "Year").text = str(v.year)
ET.SubElement(battlexml, "Simulations").text = str(v.nSimulations)
ET.SubElement(battlexml,
"RepeatUntilDefendersWin").text = str(v.repeatUntil)
defendersxml = ET.SubElement(battlexml, "Defenders")
if (v.defenders['Archers'] > 0):
ET.SubElement(defendersxml,
"Archers").text = str(v.defenders['Archers'])
if (v.defenders['Cannons'] > 0):
ET.SubElement(defendersxml,
"Cannons").text = str(v.defenders['Cannons'])
flanks = self.GetBattleFlanks(v.year, document)
if (len(flanks) > 0):
attackersxml = ET.SubElement(battlexml, "Attackers")
for f in flanks:
flankxml = ET.SubElement(attackersxml, "Flank")
if (f.standDistance):
ET.SubElement(flankxml, "StandDistance").text = str(
f.standDistance)
ET.SubElement(flankxml, "Origin").text = "[" + str(
f.origin.x) + "," + str(f.origin.y) + "]"
seg = Geometry.Segment2D(f.origin, f.target)
dir = seg.GetDirection()
ET.SubElement(flankxml, "Direction").text = "[" + str(
dir.val[0]) + "," + str(dir.val[1]) + "]"
# This is an extra field that only will be used by the Editor. It justs stores the user arrow length defined to reconstruct it on ImportXML function
# It does not change anything in the simulation, and is used only for visual purposes
arrowlength = ET.SubElement(flankxml,
"BE_Editor_ArrowLength")
arrowlength.text = str(seg.GetLength())
battalionsxml = ET.SubElement(flankxml, "Battalions")
for bk, bv in f.battalions.items():
if (bv['Number'] and (bv['Number'] > 0)):
bxml = ET.SubElement(battalionsxml, "Battalion")
ET.SubElement(bxml, "Type").text = str(bk)
ET.SubElement(bxml,
"Number").text = str(bv['Number'])
if (bv['BattalionSize']):
ET.SubElement(bxml,
"BattalionSize").text = str(
bv['BattalionSize'])
if (bv['GroupSize']):
ET.SubElement(bxml, "GroupSize").text = str(
bv['GroupSize'])
if (bv['GroupDistance']):
ET.SubElement(bxml,
"GroupDistance").text = str(
bv['GroupDistance'])
def propose_move(r):
d = np.random.normal(size=2)
rn = r + d
# print 'proposing move:',
counter = 0
# print "debug propose move:", isInsideCastle(rn), isOutsideBattlefield(rn)
while isInsideCastle(rn) or isOutsideBattlefield(rn) or not start_area.IsInside(geom.Point2D(rn[0], rn[1])):
rn = r + 2.0*np.random.normal(size=2)
counter += 1
# print '.',
print 'proposed:', counter, "moves around", r
return rn
def ImportXML(self, root, document):
main = root.find("CityEvolutions")
if (not main):
return
for groupxml in main:
if (groupxml.tag == "Group"):
try:
groupid = int(groupxml.find("ID").text)
evolutionsxml = groupxml.find("Evolutions")
for evxml in evolutionsxml:
cityevolution = BE_Objects.BE_CityEvolution()
cityevolution.groupID = groupid
arr = ast.literal_eval(evxml.find("TimeRange").text)
cityevolution.timeRange = [int(arr[0]), int(arr[1])]
cityevolution.housesPerYear = float(
evxml.find("HousesPerYear").text)
# Reconstruct the base segment and arrow
arrdir = ast.literal_eval(evxml.find("Direction").text)
direction = Geometry.Vector2D(float(arrdir[0]),
float(arrdir[1]))
direction.Normalize()
basexml = evxml.find("SegmentBase")
arrp1 = ast.literal_eval(basexml.find("P1").text)
arrp2 = ast.literal_eval(basexml.find("P2").text)
cityevolution.baseSegment.p1 = Geometry.Point2D(
float(arrp1[0]), float(arrp1[1]))
cityevolution.baseSegment.p2 = Geometry.Point2D(
float(arrp2[0]), float(arrp2[1]))
# Since arrow length is not used in the simulation, it could not be found in the incoming xml (except it is created by the editor, see ExportXML)
# If it is not present, use the base segment length as the default one
arrowlengthxml = evxml.find("BE_Editor_ArrowLength")
if (arrowlengthxml == None):
arrowlength = cityevolution.baseSegment.GetLength()
else:
arrowlength = float(arrowlengthxml.text)
mid = cityevolution.baseSegment.GetMidPoint()
mid.Move(direction, arrowlength)
cityevolution.arrow.p1 = cityevolution.baseSegment.GetMidPoint(
)
cityevolution.arrow.p2 = mid
document.AddCanvasObject(cityevolution)
except:
print "WARNING: Wrong city evolution data in CityEvolutions category"
# Parse the city expansion checkings
cityexpandxml = root.find("CityExpansion")
try:
walldims = ast.literal_eval(
cityexpandxml.find("WallDimensions").text)
self.__wallsDimensions[0] = float(walldims[0])
self.__wallsDimensions[1] = float(walldims[1])
except:
pass # Optional
try:
self.__yearsBetweenExpansions = int(
cityexpandxml.find("YearsBetweenExpansions").text)
except:
pass # Optional
if (cityexpandxml != None):
for expxml in cityexpandxml:
if (expxml.tag == "Expansion"):
try:
year = int(expxml.find("Year").text)
groupid = int(expxml.find("GroupID").text)
wxml = expxml.find("WallHeight")
if (wxml != None): # Optional
wheight = float(wxml.text)
else:
wheight = None
txml = expxml.find("TowerHeight")
if (txml != None): # Optional
theight = float(txml.text)
else:
theight = None
self.__expansions[str(groupid)] = {
'Year': year,
'WallsHeight': wheight,
'TowersHeight': theight
}
except:
print "WARNING: Wrong city expansion data in CityExpansions category"
def ImportXML(self, root, document):
main = root.find("Castle")
if (not main):
return
try:
arr = ast.literal_eval(main.find("Orientation").text)
document.GetDefaultSettings().castle.orientationVector = {
'X': arr[0],
'Y': arr[1]
}
except:
print "WARNING: Orientation tag not found in Castle category"
# Old city / houses
housesxml = main.find("OldCity")
if (housesxml != None):
for hxml in housesxml:
try:
arr = ast.literal_eval(hxml.text)
house = BE_Objects.BE_House(
Geometry.Point2D(arr[0], arr[1]))
document.AddCanvasObject(house)
except:
print "WARNING: Wrong house data in Castle category"
castle = BE_Objects.BE_Castle()
# Moat
moatxml = main.find("Moat")
if (moatxml != None):
try:
if (moatxml.find("HasWater").text == "True"):
water = True
else:
water = False
castle.SetMoat(active=True, haswater=water)
except:
print "WARNING: Moat/HasWater tag not found in Castle category"
else:
castle.SetMoat(active=False)
# Castle shape
shapexml = main.find("Shape")
if (shapexml != None):
for vertxml in shapexml:
try:
arr = ast.literal_eval(vertxml.find("Point").text)
p = Geometry.Point2D(arr[0], arr[1])
towerxml = vertxml.find("TowerType")
if (towerxml != None):
towertype = None
if (towerxml.text == "SquaredTower"):
towertype = BE_Objects.BE_Tower.TOWERTYPE_SQUARED
elif (towerxml.text == "RoundedTower"):
towertype = BE_Objects.BE_Tower.TOWERTYPE_ROUNDED
elif (towerxml.text == "Tower"):
towertype = BE_Objects.BE_Tower.TOWERTYPE_RANDOM
if (towertype != None):
tower = BE_Objects.BE_Tower(towertype=towertype,
center=p.Copy())
p.data = tower
castle.AddVertex(p)
except:
print "ERROR: Wrong castle shape in Castle category"
castle.Close()
document.AddCanvasObject(castle)
def AddVertex(self, vertex=Geometry.Point2D()):
self.__shape.append(vertex)
def Draw(self, dc):
if (self._status == self.STATUS_FINISHED):
return
if (self._status == self.STATUS_NOTSTARTED):
return
canvas = self.GetCanvas()
lastpen = dc.GetPen()
if ((self._status == self.STATUS_STARTED)
and (self.__extraStatus == self.STATUS_EXT_BASESEGMENT)):
dc.SetPen(wx.Pen(wx.Colour(0, 0, 0, wx.ALPHA_OPAQUE), 2))
dc.SetLogicalFunction(wx.INVERT)
base1 = canvas.UserToScreenCoord(self.__baseSegment.p1.x,
self.__baseSegment.p1.y)
prev = canvas.UserToScreenCoord(self._prevMousePos.x,
self._prevMousePos.y)
curr = canvas.UserToScreenCoord(self._curMousePos.x,
self._curMousePos.y)
dc.DrawLine(base1.x, base1.y, prev.x, prev.y)
dc.DrawLine(base1.x, base1.y, curr.x, curr.y)
elif ((self._status == self.STATUS_STARTED)
and (self.__extraStatus == self.STATUS_EXT_ARROW)):
if (self._prevMousePos and self._curMousePos):
dc.SetPen(wx.Pen(wx.Colour(0, 0, 0, wx.ALPHA_OPAQUE), 2))
base1 = canvas.UserToScreenCoord(self.__baseSegment.p1.x,
self.__baseSegment.p1.y)
base2 = canvas.UserToScreenCoord(self.__baseSegment.p2.x,
self.__baseSegment.p2.y)
dc.DrawLine(base1.x, base1.y, base2.x, base2.y)
mid = self.__baseSegment.GetMidPoint()
dc.SetPen(wx.Pen(wx.Colour(0, 0, 0, wx.ALPHA_OPAQUE), 2))
dc.SetLogicalFunction(wx.INVERT)
pmid = canvas.UserToScreenCoord(mid.x, mid.y)
prev = canvas.UserToScreenCoord(self._prevMousePos.x,
self._prevMousePos.y)
dc.DrawLine(pmid.x, pmid.y, prev.x, prev.y)
# Draw the arrow
if (self.__XORflag):
seg = Geometry.Segment2D(mid, self._prevMousePos)
arrow = seg.GetArrow(atEnd=True, size=30, arrowangle=20)
plist = []
for p in arrow:
parrow = canvas.UserToScreenCoord(p.x, p.y)
plist.append([parrow.x, parrow.y])
dc.DrawPolygon(plist)
self.__XORflag = True
curr = canvas.UserToScreenCoord(self._curMousePos.x,
self._curMousePos.y)
dc.DrawLine(pmid.x, pmid.y, curr.x, curr.y)
seg = Geometry.Segment2D(mid, self._curMousePos)
arrow = seg.GetArrow(atEnd=True, size=30, arrowangle=20)
plist = []
for p in arrow:
parrow = canvas.UserToScreenCoord(p.x, p.y)
plist.append([parrow.x, parrow.y])
dc.DrawPolygon(plist)
dc.SetPen(lastpen)
def Click(self, x, y):
if (self._status == self.STATUS_NOTSTARTED):
self.__baseSegment.p1 = self.GetCanvas().ScreenToUserCoord(x, y)
self._status = self.STATUS_STARTED
self.__extraStatus = self.STATUS_EXT_BASESEGMENT
self._mainWindow.Refresh()
self._mainWindow.SetCanvasCursor(wx.StockCursor(wx.CURSOR_CROSS))
elif ((self._status == self.STATUS_STARTED)
and (self.__extraStatus == self.STATUS_EXT_BASESEGMENT)):
self.__baseSegment.p2 = self.GetCanvas().ScreenToUserCoord(x, y)
self.__extraStatus = self.STATUS_EXT_ARROW
self._mainWindow.Refresh()
self._mainWindow.SetCanvasCursor(wx.StockCursor(wx.CURSOR_CROSS))
elif ((self._status == self.STATUS_STARTED)
and (self.__extraStatus == self.STATUS_EXT_ARROW)):
self.__arrowEndPoint = self.GetCanvas().ScreenToUserCoord(x, y)
dlg = BE_Dialogs.BE_CityEvolutionDlg.BE_CityEvolutionDlg(
self._mainWindow)
defdata = self._mainWindow.GetDocument().GetDefaultSettings()
gamedata = self._mainWindow.GetDocument().GetGameData()
dlg.textHousesYear.SetValue(str(
defdata.city.housesCreationPerYear))
dlg.textTimeRangeStart.SetValue(
str((gamedata.timeRange[0] - 1) * 100))
dlg.textTimeRangeEnd.SetValue(
str((gamedata.timeRange[1] - 1) * 100))
dlg.textGroupID.SetValue("0")
if (dlg.ShowModal() == wx.ID_OK):
self._receiver = BE_Objects.BE_CityEvolution()
self._receiver.baseSegment = self.__baseSegment.Copy()
self._receiver.arrow = Geometry.Segment2D(
self.__baseSegment.GetMidPoint(), self.__arrowEndPoint)
try:
self._receiver.timeRange[0] = int(
dlg.textTimeRangeStart.GetValue())
self._receiver.timeRange[1] = int(
dlg.textTimeRangeEnd.GetValue())
except:
pass
try:
self._receiver.housesPerYear = float(
dlg.textHousesYear.GetValue())
except:
pass
try:
self._receiver.groupID = int(dlg.textGroupID.GetValue())
except:
pass
self.Finish()
else:
self.Cancel()
dlg.Destroy()
self.__extraStatus = self.STATUS_EXT_NONE
def Draw(self, dc, document, canvas):
castledata = document.GetDefaultSettings().castle
lastpen = dc.GetPen()
# Draw the moat
if (self.__moat['Active']):
moatwidth = canvas.UserToScreenValue(
castledata.moat.width
) # NOTE: This sould be changed if window/viewport are not squared
if (self.__moat['HasWater']):
dc.SetPen(
wx.Pen(wx.Colour(162, 215, 245, wx.ALPHA_OPAQUE),
moatwidth))
else:
dc.SetPen(
wx.Pen(wx.Colour(128, 181, 72, wx.ALPHA_OPAQUE),
moatwidth))
# Expand the castle shape to cover it
pol = Geometry.Polygon2D()
pol.SetPointsList(self.__shape)
gpc = Geometry.GPCWrapper()
if (not gpc.IsCCW(self.__shape)):
pol.SwitchOrientation()
pol.Expand((castledata.walls.thickness / 2.0) +
(castledata.moat.width / 2))
plist = pol.GetPointsList()
i = 1
while (i < len(plist)):
p1 = canvas.UserToScreenCoord(plist[i - 1].x, plist[i - 1].y)
p2 = canvas.UserToScreenCoord(plist[i].x, plist[i].y)
dc.DrawLine(p1.x, p1.y, p2.x, p2.y)
i += 1
if (len(plist) > 2):
p1 = canvas.UserToScreenCoord(plist[-1].x, plist[-1].y)
p2 = canvas.UserToScreenCoord(plist[0].x, plist[0].y)
dc.DrawLine(p1.x, p1.y, p2.x, p2.y)
thickness = canvas.UserToScreenValue(
castledata.walls.thickness
) # NOTE: This sould be changed if window/viewport are not squared
dc.SetPen(wx.Pen(wx.Colour(130, 130, 130, wx.ALPHA_OPAQUE), thickness))
# Draw the walls
i = 1
while (i < len(self.__shape)):
p1 = canvas.UserToScreenCoord(self.__shape[i - 1].x,
self.__shape[i - 1].y)
p2 = canvas.UserToScreenCoord(self.__shape[i].x, self.__shape[i].y)
dc.DrawLine(p1.x, p1.y, p2.x, p2.y)
i += 1
if (self.__isClosed and (len(self.__shape) > 2)):
p1 = canvas.UserToScreenCoord(self.__shape[-1].x,
self.__shape[-1].y)
p2 = canvas.UserToScreenCoord(self.__shape[0].x, self.__shape[0].y)
dc.DrawLine(p1.x, p1.y, p2.x, p2.y)
# Draw the towers
i = 0
while (i < len(self.__shape)):
tower = self.__shape[i].data
if (tower):
tower.Draw(dc, document, canvas)
i += 1
dc.SetPen(lastpen)
def __init__(self, mainwindow):
self._status = self.STATUS_NOTSTARTED
self._mainWindow = mainwindow
self._curMousePos = Geometry.Point2D()
self._prevMousePos = Geometry.Point2D()
self._receiver = None
def __init__(self, mainwindow):
BE_HandlerCanvas.__init__(self, mainwindow)
self.__lastPoint = Geometry.Point2D()
def __init__(self, towertype, center=Geometry.Point2D()):
BE_Object.__init__(self)
self._type = self.CANVASOBJECT_TOWER
self.__towertype = towertype
self.__center = center
self.size = 0.0
def GetBoundingBox(self):
# Returns a BoundingBox object for current object
return Geometry.BoundingQuad()
