|
28
|
1 # Copyright (C) 2000-2001 The OpenRPG Project
|
|
|
2 #
|
|
|
3 # openrpg-dev@lists.sourceforge.net
|
|
|
4 #
|
|
|
5 # This program is free software; you can redistribute it and/or modify
|
|
|
6 # it under the terms of the GNU General Public License as published by
|
|
|
7 # the Free Software Foundation; either version 2 of the License, or
|
|
|
8 # (at your option) any later version.
|
|
|
9 #
|
|
|
10 # This program is distributed in the hope that it will be useful,
|
|
|
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
13 # GNU General Public License for more details.
|
|
|
14 #
|
|
|
15 # You should have received a copy of the GNU General Public License
|
|
|
16 # along with this program; if not, write to the Free Software
|
|
|
17 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
18 # --
|
|
|
19 #
|
|
|
20 # File: dnd3e.py
|
|
|
21 # Author: Chris Davis & Digitalxero
|
|
|
22 # Maintainer: leadb
|
|
|
23 # Version:
|
|
|
24 # $Id: dnd3e.py,v Traipse 'Ornery-Orc' prof.ebral Exp $
|
|
|
25 #
|
|
|
26 # Description: The file contains code for the dnd3e nodehanlers
|
|
|
27 #
|
|
18
|
28
|
|
28
|
29 from core import *
|
|
|
30 from containers import *
|
|
|
31 from string import * #a 1.6003
|
|
18
|
32 from inspect import * #a 1.9001
|
|
|
33 from orpg.dirpath import dir_struct
|
|
28
|
34 from orpg.tools.orpg_log import debug
|
|
|
35 from xml.etree.ElementTree import parse
|
|
36
|
36 from orpg.tools.InterParse import Parse
|
|
28
|
37
|
|
|
38 dnd3e_EXPORT = wx.NewId()
|
|
|
39 ############Global Stuff##############
|
|
|
40
|
|
|
41 HP_CUR = wx.NewId()
|
|
|
42 HP_MAX = wx.NewId()
|
|
|
43 PP_CUR = wx.NewId()
|
|
|
44 PP_MAX = wx.NewId()
|
|
|
45 PP_FRE = wx.NewId()
|
|
|
46 PP_MFRE = wx.NewId()
|
|
|
47 HOWTO_MAX = wx.NewId()
|
|
|
48
|
|
|
49 def getRoot (node): # a 1.5002 this whole function is new.
|
|
|
50 root = None
|
|
|
51 target = node
|
|
|
52 while target != None:
|
|
|
53 root = target
|
|
|
54 target = target.hparent
|
|
|
55 return root
|
|
|
56
|
|
|
57 # if a method runs getRoot for its instance and assigns the
|
|
|
58 # value returned to self.root, you can get to instances X via Y
|
|
|
59 # instance handle via invocation
|
|
|
60 # --------------- --- -----------
|
|
|
61 # classes via self.root.classes
|
|
|
62 # abilities via self.root.abilities
|
|
|
63 # pp via self.root.pp
|
|
|
64 # general via self.root.general
|
|
|
65 # saves via self.root.saves
|
|
|
66 # attacks via self.root.attacks
|
|
|
67 # ac via self.root.ac
|
|
|
68 # feats via self.root.feats
|
|
|
69 # spells via self.root.spells
|
|
|
70 # divine via self.root.divine
|
|
|
71 # powers via self.root.powers
|
|
|
72 # inventory via self.root.inventory
|
|
|
73 # hp via self.root.hp
|
|
|
74 # skills via self.root.skills
|
|
|
75 #... if other instances are needed and the instance exists uniquely,
|
|
|
76 # add to the instance you need access to in the __init__ section the following:
|
|
|
77 # self.hparent = parent # or handler if a wx instance, also add up chain
|
|
|
78 # self.root = getRoot(self)
|
|
|
79 # self.root.{instance handle} = self
|
|
|
80 # # replace {instance handle} with your designation
|
|
|
81 # then, where you need access to the instance, simply add this to the instance
|
|
|
82 # that needs to reference
|
|
|
83 # self.hparent = getRoot(self) # in the init section, if not already there
|
|
|
84 # self.root = getRoot(self) # also in the init
|
|
|
85 # then to refer to the instance where you need it:
|
|
|
86 # self.root.{instance handle}.{whatever you need}
|
|
|
87 # # replace {instance handle} with your designation
|
|
|
88 # # replace {whatever you need} with the attribute/method u want.
|
|
|
89
|
|
|
90 def safeGetAttr(node, label, defRetV=None):
|
|
|
91 cna=node.attrib
|
|
|
92 for key in cna:
|
|
|
93 if key == label: return cna[key]
|
|
|
94 return defRetV
|
|
|
95
|
|
|
96
|
|
|
97 ########End of My global Stuff########
|
|
|
98 ########Start of Main Node Handlers#######
|
|
|
99 class dnd3echar_handler(container_handler):
|
|
|
100 """ Node handler for a dnd3e charactor
|
|
|
101 <nodehandler name='?' module='dnd3e' class='dnd3echar_handler2' />
|
|
|
102 """
|
|
|
103 def __init__(self,xml_dom,tree_node):
|
|
|
104 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
105 self.Version = "v1.901" #a 1.6000 general documentation, usage.
|
|
|
106
|
|
|
107 print "dnd3echar_handler - version:", self.Version #m 1.6000
|
|
|
108
|
|
|
109 self.hparent = None
|
|
|
110 self.frame = component.get('frame')
|
|
|
111 self.child_handlers = {}
|
|
|
112 self.new_child_handler('howtouse','HowTo use this tool',dnd3ehowto,'note')
|
|
|
113 self.new_child_handler('general','GeneralInformation',dnd3egeneral,'gear')
|
|
|
114 self.new_child_handler('inventory','MoneyAndInventory',dnd3einventory,'money')
|
|
|
115 self.new_child_handler('character','ClassesAndStats',dnd3eclassnstats,'knight')
|
|
|
116 self.new_child_handler('snf','SkillsAndFeats',dnd3eskillsnfeats,'book')
|
|
|
117 self.new_child_handler('combat','Combat',dnd3ecombat,'spears')
|
|
|
118 self.new_child_handler('snp','SpellsAndPowers',dnd3esnp,'flask')
|
|
|
119 self.myeditor = None
|
|
|
120
|
|
|
121 def new_child_handler(self,tag,text,handler_class,icon='gear'):
|
|
|
122 node_list = self.xml.findall(tag)
|
|
|
123 tree = self.tree
|
|
|
124 i = self.tree.icons[icon]
|
|
|
125 new_tree_node = tree.AppendItem(self.mytree_node,text,i,i)
|
|
|
126 handler = handler_class(node_list[0],new_tree_node,self)
|
|
|
127 tree.SetPyData(new_tree_node,handler)
|
|
|
128 self.child_handlers[tag] = handler
|
|
|
129
|
|
|
130 def get_design_panel(self,parent):
|
|
|
131 return tabbed_panel(parent,self,1)
|
|
|
132
|
|
|
133 def get_use_panel(self,parent):
|
|
|
134 return tabbed_panel(parent,self,2)
|
|
|
135
|
|
|
136 def tohtml(self):
|
|
|
137 html_str = "<table><tr><td colspan=2 >"
|
|
|
138 html_str += self.general.tohtml()+"</td></tr>"
|
|
|
139 html_str += "<tr><td width='50%' valign=top >"+self.abilities.tohtml()
|
|
|
140 html_str += "<P>" + self.saves.tohtml()
|
|
|
141 html_str += "<P>" + self.attacks.tohtml()
|
|
|
142 html_str += "<P>" + self.ac.tohtml()
|
|
|
143 html_str += "<P>" + self.feats.tohtml()
|
|
|
144 html_str += "<P>" + self.spells.tohtml()
|
|
|
145 html_str += "<P>" + self.divine.tohtml()
|
|
|
146 html_str += "<P>" + self.powers.tohtml()
|
|
|
147 html_str += "<P>" + self.inventory.tohtml() +"</td>"
|
|
|
148 html_str += "<td width='50%' valign=top >"+self.classes.tohtml()
|
|
|
149 html_str += "<P>" + self.hp.tohtml()
|
|
|
150 html_str += "<P>" + self.pp.tohtml()
|
|
|
151 html_str += "<P>" + self.skills.tohtml() +"</td>"
|
|
|
152 html_str += "</tr></table>"
|
|
|
153 return html_str
|
|
|
154
|
|
|
155 def about(self):
|
|
|
156 """html_str = "<img src='" + dir_struct["icon"]
|
|
|
157 html_str += "dnd3e_logo.gif' ><br><b>dnd3e Character Tool "
|
|
|
158 html_str += self.Version+"</b>"
|
|
|
159 html_str += "<br>by Dj Gilcrease<br>digitalxero@gmail.com"
|
|
|
160 return html_str"""
|
|
|
161 text = 'dnd3e Character Tool' + self.Version +'\n'
|
|
|
162 text += 'by Dj Gilcrease digitalxero@gmail.com'
|
|
|
163 return text
|
|
|
164
|
|
|
165 ########Core Handlers are done now############
|
|
|
166 ########Onto the Sub Nodes########
|
|
|
167 ##Primary Sub Node##
|
|
|
168
|
|
|
169 class outline_panel(wx.Panel):
|
|
|
170 def __init__(self, parent, handler, wnd, txt,):
|
|
|
171 self.parent = parent #a 1.9001
|
|
|
172 wx.Panel.__init__(self, parent, -1)
|
|
|
173 self.panel = wnd(self,handler)
|
|
|
174 self.sizer = wx.StaticBoxSizer(wx.StaticBox(self,-1,txt), wx.VERTICAL)
|
|
|
175
|
|
|
176 self.sizer.Add(self.panel, 1, wx.EXPAND)
|
|
|
177 self.SetSizer(self.sizer)
|
|
|
178 self.SetAutoLayout(True)
|
|
|
179 self.Fit()
|
|
|
180
|
|
|
181 class dnd3e_char_child(node_handler):
|
|
|
182 """ Node Handler for skill. This handler will be
|
|
|
183 created by dnd3echar_handler.
|
|
|
184 """
|
|
|
185 def __init__(self,xml_dom,tree_node,parent):
|
|
|
186 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
187 self.char_hander = parent
|
|
|
188 self.drag = False
|
|
|
189 self.frame = component.get('frame')
|
|
|
190 self.myeditor = None
|
|
|
191
|
|
|
192 def on_drop(self,evt):
|
|
|
193 pass
|
|
|
194
|
|
|
195 def on_rclick(self,evt):
|
|
|
196 pass
|
|
|
197
|
|
|
198 def on_ldclick(self,evt):
|
|
|
199 return
|
|
|
200
|
|
|
201 def on_html(self,evt):
|
|
|
202 html_str = self.tohtml()
|
|
|
203 wnd = http_html_window(self.frame.note,-1)
|
|
|
204 wnd.title = self.xml.get('name')
|
|
|
205 self.frame.add_panel(wnd)
|
|
|
206 wnd.SetPage(html_str)
|
|
|
207
|
|
|
208 def get_design_panel(self,parent):
|
|
|
209 pass
|
|
|
210
|
|
|
211 def get_use_panel(self,parent):
|
|
|
212 return self.get_design_panel(parent)
|
|
|
213
|
|
|
214 def delete(self):
|
|
|
215 pass
|
|
|
216
|
|
|
217 ###Child Nodes Organized the way they are in the XML for easier viewing#### #m 1.5002 corrected typo.
|
|
|
218 class dnd3ehowto(dnd3e_char_child): #m 1.5002 corrected string below to reflect "how to"
|
|
|
219 """ Node Handler for how to instructions. This handler will be
|
|
|
220 created by dnd3echar_handler.
|
|
|
221 """
|
|
|
222 def __init__(self,xml_dom,tree_node,parent):
|
|
|
223 dnd3e_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
224 self.hparent = parent
|
|
|
225
|
|
|
226 def get_design_panel(self,parent):
|
|
|
227 wnd = howto_panel(parent, self)
|
|
|
228 wnd.title = "How To"
|
|
|
229 return wnd
|
|
|
230
|
|
|
231 class howto_panel(wx.Panel):
|
|
|
232 def __init__(self, parent, handler):
|
|
|
233 wx.Panel.__init__(self, parent, -1)
|
|
|
234
|
|
|
235 pname = handler.xml.set("name", 'How To')
|
|
|
236 self.sizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'How To'), wx.VERTICAL)
|
|
|
237 self.xml = handler.xml
|
|
|
238 n_list = self.xml.getchildren()
|
|
|
239 for n in n_list:
|
|
|
240 self.sizer.Add(wx.StaticText(self, -1, n.text), 1, wx.EXPAND)
|
|
|
241 self.SetSizer(self.sizer)
|
|
|
242 self.SetAutoLayout(True)
|
|
|
243 self.Fit()
|
|
|
244
|
|
|
245 class dnd3egeneral(dnd3e_char_child):
|
|
|
246 """ Node Handler for general information. This handler will be
|
|
|
247 created by dnd3echar_handler.
|
|
|
248 """
|
|
|
249 def __init__(self,xml_dom,tree_node,parent):
|
|
|
250 dnd3e_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
251 self.hparent = parent
|
|
|
252 self.root = getRoot(self)
|
|
|
253 self.root.general = self
|
|
|
254 self.charName = self.get_char_name()
|
|
|
255
|
|
|
256 def get_design_panel(self,parent):
|
|
|
257 wnd = outline_panel(parent,self,gen_grid,"General Information")
|
|
|
258 wnd.title = "General Info"
|
|
|
259 return wnd
|
|
|
260
|
|
|
261 def tohtml(self):
|
|
|
262 n_list = self.xml.getchildren()
|
|
|
263 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>General Information</th></tr><tr><td>"
|
|
|
264 for n in n_list:
|
|
|
265 html_str += "<B>"+n.tag.capitalize() +":</B> "
|
|
|
266 html_str += n.text + ", "
|
|
|
267 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
268 return html_str
|
|
|
269
|
|
|
270 def on_name_change(self,name):
|
|
|
271 self.char_hander.rename(name)
|
|
|
272 self.charName = name
|
|
|
273
|
|
|
274 def get_char_name( self ):
|
|
|
275 node = self.xml.findall( 'name' )[0]
|
|
|
276 return node.text
|
|
|
277
|
|
|
278 class gen_grid(wx.grid.Grid):
|
|
|
279 """grid for gen info"""
|
|
|
280 def __init__(self, parent, handler):
|
|
|
281 pname = handler.xml.set("name", 'General')
|
|
|
282 self.hparent = handler
|
|
|
283
|
|
|
284 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
285 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
286 self.handler = handler
|
|
|
287 n_list = handler.xml.getchildren()
|
|
|
288 self.CreateGrid(len(n_list),2)
|
|
|
289 self.SetRowLabelSize(0)
|
|
|
290 self.SetColLabelSize(0)
|
|
|
291 self.n_list = n_list
|
|
|
292 i = 0
|
|
|
293 for i in range(len(n_list)): self.refresh_row(i)
|
|
|
294
|
|
|
295 def on_cell_change(self,evt):
|
|
|
296 row = evt.GetRow()
|
|
|
297 col = evt.GetCol()
|
|
|
298 value = self.GetCellValue(row,col)
|
|
|
299 self.n_list[row].text = value
|
|
|
300 if row==0: self.handler.on_name_change(value)
|
|
|
301
|
|
|
302 def refresh_row(self,rowi):
|
|
|
303 self.SetCellValue(rowi,0,self.n_list[rowi].tag)
|
|
|
304 self.SetReadOnly(rowi,0)
|
|
|
305 self.SetCellValue(rowi,1,self.n_list[rowi].text)
|
|
|
306 self.AutoSizeColumn(1)
|
|
|
307
|
|
|
308 class dnd3einventory(dnd3e_char_child):
|
|
|
309 """ Node Handler for general information. This handler will be
|
|
|
310 created by dnd3echar_handler.
|
|
|
311 """
|
|
|
312 def __init__(self,xml_dom,tree_node,parent):
|
|
|
313 dnd3e_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
314 self.hparent = parent
|
|
|
315 self.root = getRoot(self)
|
|
|
316 self.root.inventory = self
|
|
|
317
|
|
|
318 def get_design_panel(self,parent):
|
|
|
319 wnd = inventory_pane(parent, self) #outline_panel(parent,self,inventory_grid,"Inventory")
|
|
|
320 wnd.title = "Inventory"
|
|
|
321 return wnd
|
|
|
322
|
|
|
323 def tohtml(self):
|
|
|
324 n_list = self.xml.getchildren()
|
|
|
325 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>General Information</th></tr><tr><td>"
|
|
|
326 for n in n_list:
|
|
|
327 html_str += "<B>"+n.tag.capitalize()+":</B> "
|
|
|
328 html_str += n.text + "<br>"
|
|
|
329 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
330 return html_str
|
|
|
331
|
|
|
332 class inventory_pane(wx.Panel):
|
|
|
333 def __init__(self, parent, handler):
|
|
|
334 wx.Panel.__init__(self, parent, wx.ID_ANY)
|
|
|
335 self.n_list = handler.xml.getchildren()
|
|
|
336 self.autosize = False
|
|
|
337 self.sizer = wx.StaticBoxSizer(wx.StaticBox(self, wx.ID_ANY, "Inventory"), wx.VERTICAL)
|
|
|
338 self.lang = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_MULTILINE | wx.TE_BESTWRAP, name="Languages")
|
|
|
339 self.gear = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_MULTILINE | wx.TE_BESTWRAP, name="Gear")
|
|
|
340 self.magic = wx.TextCtrl(self, wx.ID_ANY, "", style=wx.TE_MULTILINE | wx.TE_BESTWRAP, name="Magic")
|
|
|
341 self.grid = wx.grid.Grid(self, wx.ID_ANY, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
342 self.grid.CreateGrid(len(self.n_list)-3,2)
|
|
|
343 self.grid.SetRowLabelSize(0)
|
|
|
344 self.grid.SetColLabelSize(0)
|
|
|
345 for i in xrange(len(self.n_list)): self.refresh_row(i)
|
|
|
346 sizer1 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
347 sizer1.Add(self.grid, 1, wx.EXPAND)
|
|
|
348 sizer1.Add(self.lang, 1, wx.EXPAND)
|
|
|
349 self.sizer.Add(sizer1, 0, wx.EXPAND)
|
|
|
350 sizer2 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
351 sizer2.Add(self.gear, 1, wx.EXPAND)
|
|
|
352 sizer2.Add(self.magic, 1, wx.EXPAND)
|
|
|
353 self.sizer.Add(sizer2, 1, wx.EXPAND)
|
|
|
354 self.SetSizer(self.sizer)
|
|
|
355 self.SetAutoLayout(True)
|
|
|
356 self.Fit()
|
|
|
357 self.Bind(wx.EVT_TEXT, self.onTextNodeChange, self.lang)
|
|
|
358 self.Bind(wx.EVT_TEXT, self.onTextNodeChange, self.gear)
|
|
|
359 self.Bind(wx.EVT_TEXT, self.onTextNodeChange, self.magic)
|
|
|
360 self.Bind(wx.grid.EVT_GRID_EDITOR_HIDDEN, self.on_cell_change, self.grid)
|
|
|
361
|
|
|
362 def fillTextNode(self, name, value):
|
|
|
363 if name == 'Languages': self.lang.SetValue(value)
|
|
|
364 elif name == 'Gear': self.gear.SetValue(value)
|
|
|
365 elif name == 'Magic': self.magic.SetValue(value)
|
|
|
366
|
|
|
367 def onTextNodeChange(self, event):
|
|
|
368 id = event.GetId()
|
|
|
369 if id == self.gear.GetId():
|
|
|
370 nodeName = 'Gear'
|
|
|
371 value = self.gear.GetValue()
|
|
|
372 elif id == self.magic.GetId():
|
|
|
373 nodeName = 'Magic'
|
|
|
374 value = self.magic.GetValue()
|
|
|
375 elif id == self.lang.GetId():
|
|
|
376 nodeName = 'Languages'
|
|
|
377 value = self.lang.GetValue()
|
|
|
378 for node in self.n_list:
|
|
|
379 if node.tag == nodeName:
|
|
|
380 node.text = value
|
|
|
381
|
|
|
382 def saveMoney(self, row, col):
|
|
|
383 value = self.grid.GetCellValue(row, col)
|
|
|
384 self.n_list[row].text = value
|
|
|
385
|
|
|
386 def on_cell_change(self, evt):
|
|
|
387 row = evt.GetRow()
|
|
|
388 col = evt.GetCol()
|
|
|
389 self.grid.AutoSizeColumn(col)
|
|
|
390 wx.CallAfter(self.saveMoney, row, col)
|
|
|
391
|
|
|
392 def refresh_row(self, row):
|
|
|
393 tagname = self.n_list[row].tag
|
|
|
394 value = self.n_list[row].text
|
|
|
395 if tagname == 'Gear': self.fillTextNode(tagname, value)
|
|
|
396 elif tagname == 'Magic': self.fillTextNode(tagname, value)
|
|
|
397 elif tagname == 'Languages': self.fillTextNode(tagname, value)
|
|
|
398 else:
|
|
|
399 self.grid.SetCellValue(row, 0, tagname)
|
|
|
400 self.grid.SetReadOnly(row, 0)
|
|
|
401 self.grid.SetCellValue(row, 1, value)
|
|
|
402 self.grid.AutoSize()
|
|
|
403
|
|
|
404
|
|
|
405 class dnd3eclassnstats(dnd3e_char_child):
|
|
|
406 """ Node handler for a dnd3e charactor
|
|
|
407 <nodehandler name='?' module='dnd3e' class='dnd3echar_handler2' />
|
|
|
408 """
|
|
|
409 def __init__(self,xml_dom,tree_node,parent):
|
|
|
410 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
411 self.hparent = parent
|
|
|
412 dnd3e_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
413 self.frame = component.get('frame')
|
|
|
414 self.child_handlers = {}
|
|
|
415 self.new_child_handler('abilities','Abilities Scores',dnd3eability,'gear')
|
|
|
416 self.new_child_handler('classes','Classes',dnd3eclasses,'knight')
|
|
|
417 self.new_child_handler('saves','Saves',dnd3esaves,'skull')
|
|
|
418 self.myeditor = None
|
|
|
419
|
|
|
420 def new_child_handler(self,tag,text,handler_class,icon='gear'):
|
|
|
421 node_list = self.xml.findall(tag)
|
|
|
422 tree = self.tree
|
|
|
423 i = self.tree.icons[icon]
|
|
|
424 new_tree_node = tree.AppendItem(self.mytree_node,text,i,i)
|
|
|
425 handler = handler_class(node_list[0],new_tree_node,self)
|
|
|
426 tree.SetPyData(new_tree_node,handler)
|
|
|
427 self.child_handlers[tag] = handler
|
|
|
428
|
|
|
429 def get_design_panel(self,parent):
|
|
|
430 return tabbed_panel(parent,self,1)
|
|
|
431
|
|
|
432 def get_use_panel(self,parent):
|
|
|
433 print 'here'
|
|
|
434 return tabbed_panel(parent,self,2)
|
|
|
435
|
|
|
436 class class_char_child(node_handler):
|
|
|
437 """ Node Handler for skill. This handler will be
|
|
|
438 created by dnd3echar_handler.
|
|
|
439 """
|
|
|
440 def __init__(self,xml_dom,tree_node,parent):
|
|
|
441 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
442 self.char_hander = parent
|
|
|
443 self.drag = False
|
|
|
444 self.frame = component.get('frame')
|
|
|
445 self.myeditor = None
|
|
|
446
|
|
|
447 def on_drop(self,evt):
|
|
|
448 pass
|
|
|
449
|
|
|
450 def on_rclick(self,evt):
|
|
|
451 pass
|
|
|
452
|
|
|
453 def on_ldclick(self,evt):
|
|
|
454 return
|
|
|
455
|
|
|
456 def on_html(self,evt):
|
|
|
457 html_str = self.tohtml()
|
|
|
458 wnd = http_html_window(self.frame.note,-1)
|
|
|
459 wnd.title = self.xml.get('name')
|
|
|
460 self.frame.add_panel(wnd)
|
|
|
461 wnd.SetPage(html_str)
|
|
|
462
|
|
|
463 def get_design_panel(self,parent):
|
|
|
464 pass
|
|
|
465
|
|
|
466 def get_use_panel(self,parent):
|
|
|
467 return self.get_design_panel(parent)
|
|
|
468
|
|
|
469 def delete(self):
|
|
|
470 pass
|
|
|
471
|
|
|
472 class dnd3eability(class_char_child):
|
|
|
473 """ Node Handler for ability. This handler will be
|
|
|
474 created by dnd3echar_handler.
|
|
|
475 """
|
|
|
476 def __init__(self,xml_dom,tree_node,parent):
|
|
|
477 class_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
478 self.hparent = parent
|
|
|
479 self.root = getRoot(self)
|
|
|
480 self.root.abilities = self
|
|
|
481 self.abilities = {}
|
|
|
482 node_list = self.xml.findall('stat')
|
|
|
483 tree = self.tree
|
|
|
484 icons = tree.icons
|
|
|
485 for n in node_list:
|
|
|
486 name = n.get('abbr')
|
|
|
487 self.abilities[name] = n
|
|
|
488 new_tree_node = tree.AppendItem( self.mytree_node, name, icons['gear'], icons['gear'] )
|
|
|
489 tree.SetPyData( new_tree_node, self )
|
|
|
490
|
|
|
491 def on_rclick( self, evt ):
|
|
|
492 item = self.tree.GetSelection()
|
|
|
493 name = self.tree.GetItemText( item )
|
|
|
494 if not item == self.mytree_node:
|
|
|
495 mod = self.get_mod( name )
|
|
|
496 if mod >= 0: mod1 = "+"
|
|
|
497 else: mod1 = ""
|
|
|
498 chat = self.chat
|
|
|
499 txt = '%s check: [1d20%s%s]' % ( name, mod1, mod )
|
|
|
500 chat.ParsePost( txt, True, True )
|
|
|
501
|
|
|
502 def get_mod(self,abbr):
|
|
|
503 score = int(self.abilities[abbr].get('base'))
|
|
|
504 mod = (score - 10) / 2
|
|
|
505 mod = int(mod)
|
|
|
506 return mod
|
|
|
507
|
|
|
508 def set_score(self,abbr,score):
|
|
|
509 if score >= 0:
|
|
|
510 self.abilities[abbr].set("base",str(score))
|
|
|
511
|
|
|
512 def get_design_panel(self,parent):
|
|
|
513 wnd = outline_panel(parent,self,abil_grid,"Abilities")
|
|
|
514 wnd.title = "Abilities (edit)"
|
|
|
515 return wnd
|
|
|
516
|
|
|
517 def tohtml(self):
|
|
|
518 html_str = """<table border='1' width=100%><tr BGCOLOR=#E9E9E9 ><th width='50%'>Ability</th>
|
|
|
519 <th>Base</th><th>Modifier</th></tr>"""
|
|
|
520 node_list = self.xml.findall('stat')
|
|
|
521 for n in node_list:
|
|
|
522 name = n.get('name')
|
|
|
523 abbr = n.get('abbr')
|
|
|
524 base = n.get('base')
|
|
|
525 mod = str(self.get_mod(abbr))
|
|
|
526 if int(mod) >= 0: mod1 = "+"
|
|
|
527 else: mod1 = ""
|
|
|
528 html_str = (html_str + "<tr ALIGN='center'><td>"+
|
|
|
529 name+"</td><td>"+base+'</td><td>%s%s</td></tr>' % (mod1, mod))
|
|
|
530 html_str = html_str + "</table>"
|
|
|
531 return html_str
|
|
|
532
|
|
|
533 class abil_grid(wx.grid.Grid):
|
|
|
534 """grid for abilities"""
|
|
|
535 def __init__(self, parent, handler):
|
|
|
536 pname = handler.xml.set("name", 'Stats')
|
|
|
537 self.hparent = handler
|
|
|
538 self.root = getRoot(self)
|
|
|
539
|
|
|
540 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
541 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
542 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
543 self.handler = handler
|
|
|
544 stats = handler.xml.findall('stat')
|
|
|
545 self.CreateGrid(len(stats),3)
|
|
|
546 self.SetRowLabelSize(0)
|
|
|
547 col_names = ['Ability','Score','Modifier']
|
|
|
548 for i in range(len(col_names)): self.SetColLabelValue(i,col_names[i])
|
|
|
549 self.stats = stats
|
|
|
550 i = 0
|
|
|
551 for i in range(len(stats)): self.refresh_row(i)
|
|
|
552 self.char_wnd = None
|
|
|
553
|
|
|
554 def on_cell_change(self,evt):
|
|
|
555 row = evt.GetRow()
|
|
|
556 col = evt.GetCol()
|
|
|
557 value = self.GetCellValue(row,col)
|
|
|
558 try:
|
|
|
559 int(value)
|
|
|
560 self.stats[row].set('base',value)
|
|
|
561 self.refresh_row(row)
|
|
|
562 except:
|
|
|
563 self.SetCellValue(row,col,"0")
|
|
|
564 if self.char_wnd: self.char_wnd.refresh_data()
|
|
|
565
|
|
|
566 def refresh_row(self,rowi):
|
|
|
567 s = self.stats[rowi]
|
|
|
568 name = s.get('name')
|
|
|
569 abbr = s.get('abbr')
|
|
|
570 self.SetCellValue(rowi,0,name)
|
|
|
571 self.SetReadOnly(rowi,0)
|
|
|
572 self.SetCellValue(rowi,1,s.get('base'))
|
|
|
573 self.SetCellValue(rowi,2,str(self.handler.get_mod(abbr)))
|
|
|
574 self.SetReadOnly(rowi,2)
|
|
|
575 self.root.saves.refresh_data()
|
|
|
576 self.root.attacks.refreshMRdata()
|
|
|
577
|
|
|
578 def on_size(self,evt):
|
|
|
579 (w,h) = self.GetClientSizeTuple()
|
|
|
580 cols = self.GetNumberCols()
|
|
|
581 col_w = w/(cols+2)
|
|
|
582 self.SetColSize(0,col_w*3)
|
|
|
583 for i in range(1,cols): self.SetColSize(i,col_w)
|
|
|
584 evt.Skip()
|
|
|
585 self.Refresh()
|
|
|
586
|
|
|
587 def refresh_data(self):
|
|
|
588 for r in range(self.GetNumberRows()-1): self.refresh_row(r)
|
|
|
589
|
|
|
590 class dnd3eclasses(class_char_child):
|
|
|
591 """ Node Handler for classes. This handler will be
|
|
|
592 created by dnd3echar_handler.
|
|
|
593 """
|
|
|
594 def __init__(self,xml_dom,tree_node,parent):
|
|
|
595 class_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
596 self.hparent = parent
|
|
|
597 self.root = getRoot(self)
|
|
|
598 self.root.classes = self
|
|
|
599
|
|
|
600 def get_design_panel(self,parent):
|
|
|
601 wnd = outline_panel(parent,self,class_panel,"Classes")
|
|
|
602 wnd.title = "Classes"
|
|
|
603 return wnd
|
|
|
604
|
|
|
605 def tohtml(self):
|
|
|
606 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>Classes</th></tr><tr><td>"
|
|
|
607 n_list = self.xml.getchildren()
|
|
|
608 for n in n_list: html_str += n.get('name') + " ("+n.get('level')+"), "
|
|
|
609 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
610 return html_str
|
|
|
611
|
|
|
612 def get_char_lvl( self, attr ):
|
|
|
613 node_list = self.xml.findall('class')
|
|
|
614 tot = 0
|
|
|
615 for n in node_list:
|
|
|
616 lvl = n.get('level')
|
|
|
617 tot += int(lvl)
|
|
|
618 type = n.get('name')
|
|
|
619 if attr == "level": return lvl
|
|
|
620 elif attr == "class": return type
|
|
|
621 if attr == "lvl": return tot
|
|
|
622
|
|
|
623 def get_class_lvl( self, classN ):
|
|
|
624 node_list = self.xml.findall('class')
|
|
|
625 for n in node_list:
|
|
|
626 lvl = n.get('level')
|
|
|
627 type = n.get('name')
|
|
|
628 if classN == type: return lvl
|
|
|
629
|
|
|
630 class class_panel(wx.Panel):
|
|
|
631 def __init__(self, parent, handler):
|
|
|
632 pname = handler.xml.set("name", 'Class')
|
|
|
633
|
|
|
634 wx.Panel.__init__(self, parent, -1)
|
|
|
635 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
636 sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
637 sizer.Add(self.grid, 1, wx.EXPAND)
|
|
|
638
|
|
|
639 sizer1 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
640 sizer1.Add(wx.Button(self, 10, "Remove Class"), 0, wx.EXPAND)
|
|
|
641 sizer1.Add(wx.Size(10,10))
|
|
|
642 sizer1.Add(wx.Button(self, 20, "Add Class"), 0, wx.EXPAND)
|
|
|
643
|
|
|
644 sizer.Add(sizer1, 0, wx.EXPAND)
|
|
|
645 self.sizer = sizer
|
|
|
646 self.SetSizer(self.sizer)
|
|
|
647 self.SetAutoLayout(True)
|
|
|
648 self.Fit()
|
|
|
649
|
|
|
650 self.Bind(wx.EVT_BUTTON, self.on_remove, id=10)
|
|
|
651 self.Bind(wx.EVT_BUTTON, self.on_add, id=20)
|
|
|
652 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
653
|
|
|
654 n_list = handler.xml.getchildren()
|
|
|
655 self.n_list = n_list
|
|
|
656 self.xml = handler.xml
|
|
|
657 self.grid.CreateGrid(len(n_list),2,1)
|
|
|
658 self.grid.SetRowLabelSize(0)
|
|
|
659 self.grid.SetColLabelValue(0,"Class")
|
|
|
660 self.grid.SetColLabelValue(1,"Level")
|
|
|
661 for i in range(len(n_list)): self.refresh_row(i)
|
|
|
662 self.temp_dom = None
|
|
|
663
|
|
|
664 def on_cell_change(self,evt):
|
|
|
665 row = evt.GetRow()
|
|
|
666 col = evt.GetCol()
|
|
|
667 value = self.grid.GetCellValue(row,col)
|
|
|
668 try:
|
|
|
669 int(value)
|
|
|
670 self.n_list[row].set('level',value)
|
|
|
671 except: self.grid.SetCellValue(row,col,"1")
|
|
|
672
|
|
|
673 def refresh_row(self,i):
|
|
|
674 n = self.n_list[i]
|
|
|
675 name = n.get('name')
|
|
|
676 level = n.get('level')
|
|
|
677 self.grid.SetCellValue(i,0,name)
|
|
|
678 self.grid.SetReadOnly(i,0)
|
|
|
679 self.grid.SetCellValue(i,1,level)
|
|
|
680
|
|
|
681 def on_remove(self,evt):
|
|
|
682 rows = self.grid.GetNumberRows()
|
|
|
683 for i in range(rows):
|
|
|
684 if self.grid.IsInSelection(i,0):
|
|
|
685 self.grid.DeleteRows(i)
|
|
|
686 self.xml.remove(self.n_list[i])
|
|
|
687
|
|
|
688 def on_add(self,evt):
|
|
|
689 if not self.temp_dom:
|
|
|
690 tree = parse(dir_struct["dnd3e"]+"dnd3eclasses.xml")
|
|
|
691 xml_dom = tree.getroot()
|
|
|
692 self.temp_dom = xml_dom
|
|
|
693 f_list = self.temp_dom.findall('class')
|
|
|
694 opts = []
|
|
|
695 for f in f_list: opts.append(f.get('name'))
|
|
|
696 dlg = wx.SingleChoiceDialog(self,'Choose Class','Classes',opts)
|
|
|
697 if dlg.ShowModal() == wx.ID_OK:
|
|
|
698 i = dlg.GetSelection()
|
|
|
699 new_node = self.xml.append(f_list[i])
|
|
|
700 self.grid.AppendRows(1)
|
|
|
701 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
702 dlg.Destroy()
|
|
|
703
|
|
|
704 def on_size(self,event):
|
|
|
705 s = self.GetClientSizeTuple()
|
|
|
706 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
707 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
708 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
709 cols = self.grid.GetNumberCols()
|
|
|
710 col_w = w/(cols)
|
|
|
711 for i in range(0,cols): self.grid.SetColSize(i,col_w)
|
|
|
712
|
|
|
713
|
|
|
714 class dnd3esaves(class_char_child):
|
|
|
715 """ Node Handler for saves. This handler will be
|
|
|
716 created by dnd3echar_handler.
|
|
|
717 """
|
|
|
718 def __init__(self,xml_dom,tree_node,parent):
|
|
|
719 class_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
720 self.hparent = parent
|
|
|
721 self.saveGridFrame = []
|
|
|
722
|
|
|
723 tree = self.tree
|
|
|
724 icons = self.tree.icons
|
|
|
725
|
|
|
726 self.root = getRoot(self)
|
|
|
727 self.root.saves = self
|
|
|
728 node_list = self.xml.findall('save')
|
|
|
729 self.saves={}
|
|
|
730 for n in node_list:
|
|
|
731 name = n.get('name')
|
|
|
732 self.saves[name] = n
|
|
|
733 new_tree_node = tree.AppendItem(self.mytree_node,name,icons['gear'],icons['gear'])
|
|
|
734 tree.SetPyData(new_tree_node,self)
|
|
|
735
|
|
|
736
|
|
|
737 def refresh_data(self):
|
|
|
738 # of the attack chart.
|
|
|
739 # count backwards, maintains context despite "removes"
|
|
|
740 for i in range(len(self.saveGridFrame)-1,-1,-1):
|
|
|
741 x = self.saveGridFrame[i]
|
|
|
742 if x == None: x.refresh_data()
|
|
|
743 else: self.saveGridFrame.remove(x)
|
|
|
744
|
|
|
745 def get_mod(self,name):
|
|
|
746 save = self.saves[name]
|
|
|
747 stat = save.get('stat')
|
|
|
748 stat_mod = self.root.abilities.get_mod(stat)
|
|
|
749 base = int(save.get('base'))
|
|
|
750 miscmod = int(save.get('miscmod'))
|
|
|
751 magmod = int(save.get('magmod'))
|
|
|
752 total = stat_mod + base + miscmod + magmod
|
|
|
753 return total
|
|
|
754
|
|
|
755 def on_rclick(self,evt):
|
|
|
756 item = self.tree.GetSelection()
|
|
|
757 name = self.tree.GetItemText(item)
|
|
|
758 if item == self.mytree_node:
|
|
|
759 pass
|
|
|
760 return
|
|
|
761 else:
|
|
|
762 mod = self.get_mod(name)
|
|
|
763 if mod >= 0: mod1 = "+"
|
|
|
764 else: mod1 = ""
|
|
|
765 chat = self.chat
|
|
|
766 txt = '%s save: [1d20%s%s]' % (name, mod1, mod)
|
|
36
|
767 Parse.Post( txt, self.chat, True, True )
|
|
28
|
768
|
|
|
769 def get_design_panel(self,parent):
|
|
|
770 wnd = outline_panel(parent,self,save_grid,"Saves")
|
|
|
771 wnd.title = "Saves"
|
|
|
772 return wnd
|
|
|
773
|
|
|
774 def tohtml(self):
|
|
|
775 html_str = """<table border='1' width=100% ><tr BGCOLOR=#E9E9E9 >
|
|
|
776 <th width='30%'>Save</th>
|
|
|
777 <th>Key</th><th>Base</th><th>Abil</th><th>Magic</th>
|
|
|
778 <th>Misc</th><th>Total</th></tr>"""
|
|
|
779 node_list = self.xml.findall('save')
|
|
|
780 for n in node_list:
|
|
|
781 name = n.get('name')
|
|
|
782 stat = n.get('stat')
|
|
|
783 base = n.get('base')
|
|
|
784 html_str = html_str + "<tr ALIGN='center'><td>"+name+"</td><td>"+stat+"</td><td>"+base+"</td>"
|
|
|
785 stat_mod = self.root.abilities.get_mod(stat)
|
|
|
786
|
|
|
787 mag = n.get('magmod')
|
|
|
788 misc = n.get('miscmod')
|
|
|
789 mod = str(self.get_mod(name))
|
|
|
790 if mod >= 0: mod1 = "+"
|
|
|
791 else: mod1 = ""
|
|
|
792 html_str = html_str + "<td>"+str(stat_mod)+"</td><td>"+mag+"</td>"
|
|
|
793 html_str = html_str + '<td>'+misc+'</td><td>%s%s</td></tr>' % (mod1, mod)
|
|
|
794 html_str = html_str + "</table>"
|
|
|
795 return html_str
|
|
|
796
|
|
|
797 #mark6
|
|
|
798 class save_grid(wx.grid.Grid):
|
|
|
799 """grid for saves"""
|
|
|
800 def __init__(self, parent, handler):
|
|
|
801 pname = handler.xml.set("name", 'Saves')
|
|
|
802 self.hparent = handler
|
|
|
803 self.root = getRoot(self)
|
|
|
804 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
805 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
806 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
807 self.handler = handler
|
|
|
808 saves = handler.xml.findall('save')
|
|
|
809 self.CreateGrid(len(saves),7)
|
|
|
810 self.SetRowLabelSize(0)
|
|
|
811 col_names = ['Save','Key','base','Abil','Magic','Misc','Total']
|
|
|
812 for i in range(len(col_names)): self.SetColLabelValue(i,col_names[i])
|
|
|
813 self.saves = saves
|
|
|
814 i = 0
|
|
|
815 for i in range(len(saves)): self.refresh_row(i)
|
|
|
816 climber = parent
|
|
|
817 nameNode = climber.GetClassName()
|
|
|
818 while nameNode != 'wxFrame':
|
|
|
819 climber = climber.parent
|
|
|
820 nameNode = climber.GetClassName()
|
|
|
821 masterFrame=climber
|
|
|
822 masterFrame.refresh_data=self.refresh_data
|
|
|
823 handler.saveGridFrame.append(masterFrame)
|
|
|
824
|
|
|
825 def on_cell_change(self,evt):
|
|
|
826 row = evt.GetRow()
|
|
|
827 col = evt.GetCol()
|
|
|
828 value = self.GetCellValue(row,col)
|
|
|
829 try:
|
|
|
830 int(value)
|
|
|
831 if col == 2: self.saves[row].set('base',value)
|
|
|
832 elif col == 4: self.saves[row].set('magmod',value)
|
|
|
833 elif col == 5: self.saves[row].set('miscmod',value)
|
|
|
834 self.refresh_row(row)
|
|
|
835 except: self.SetCellValue(row,col,"0")
|
|
|
836
|
|
|
837 def refresh_row(self,rowi):
|
|
|
838 s = self.saves[rowi]
|
|
|
839 name = s.get('name')
|
|
|
840 self.SetCellValue(rowi,0,name)
|
|
|
841 self.SetReadOnly(rowi,0)
|
|
|
842 stat = s.get('stat')
|
|
|
843 self.SetCellValue(rowi,1,stat)
|
|
|
844 self.SetReadOnly(rowi,1)
|
|
|
845 self.SetCellValue(rowi,2,s.get('base'))
|
|
|
846 self.SetCellValue(rowi,3,str(self.root.abilities.get_mod(stat)))
|
|
|
847 self.SetReadOnly(rowi,3)
|
|
|
848 self.SetCellValue(rowi,4,s.get('magmod'))
|
|
|
849 self.SetCellValue(rowi,5,s.get('miscmod'))
|
|
|
850 mod = str(self.handler.get_mod(name))
|
|
|
851 self.SetCellValue(rowi,6,mod)
|
|
|
852 self.SetReadOnly(rowi,6)
|
|
|
853
|
|
|
854 def on_size(self,evt):
|
|
|
855 (w,h) = self.GetClientSizeTuple()
|
|
|
856 cols = self.GetNumberCols()
|
|
|
857 col_w = w/(cols+2)
|
|
|
858 self.SetColSize(0,col_w*3)
|
|
|
859 for i in range(1,cols): self.SetColSize(i,col_w)
|
|
|
860 evt.Skip()
|
|
|
861 self.Refresh()
|
|
|
862
|
|
|
863 def refresh_data(self):
|
|
|
864 for r in range(self.GetNumberRows()): self.refresh_row(r)
|
|
|
865
|
|
|
866 class dnd3eskillsnfeats(dnd3e_char_child):
|
|
|
867 """ Node handler for a dnd3e charactor
|
|
|
868 <nodehandler name='?' module='dnd3e' class='dnd3echar_handler2' />
|
|
|
869 """
|
|
|
870 def __init__(self,xml_dom,tree_node,parent):
|
|
|
871 self.hparent = parent
|
|
|
872 self.root = getRoot(self)
|
|
|
873 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
874 dnd3e_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
875 self.frame = component.get('frame')
|
|
|
876 self.child_handlers = {}
|
|
|
877 self.new_child_handler('skills','Skills',dnd3eskill,'book')
|
|
|
878 self.new_child_handler('feats','Feats',dnd3efeats,'book')
|
|
|
879 self.myeditor = None
|
|
|
880
|
|
|
881 def new_child_handler(self,tag,text,handler_class,icon='gear'):
|
|
|
882 node_list = self.xml.findall(tag)
|
|
|
883 tree = self.tree
|
|
|
884 i = self.tree.icons[icon]
|
|
|
885 new_tree_node = tree.AppendItem(self.mytree_node,text,i,i)
|
|
|
886 handler = handler_class(node_list[0],new_tree_node,self)
|
|
|
887 tree.SetPyData(new_tree_node,handler)
|
|
|
888 self.child_handlers[tag] = handler
|
|
|
889
|
|
|
890 def get_design_panel(self,parent):
|
|
|
891 return tabbed_panel(parent,self,1)
|
|
|
892
|
|
|
893 def get_use_panel(self,parent):
|
|
|
894 return tabbed_panel(parent,self,2)
|
|
|
895
|
|
|
896 class skills_char_child(node_handler):
|
|
|
897 """ Node Handler for skill. This handler will be
|
|
|
898 created by dnd3echar_handler.
|
|
|
899 """
|
|
|
900 def __init__(self,xml_dom,tree_node,parent):
|
|
|
901 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
902 self.char_hander = parent
|
|
|
903 self.drag = False
|
|
|
904 self.frame = component.get('frame')
|
|
|
905 self.myeditor = None
|
|
|
906
|
|
|
907 def on_drop(self,evt):
|
|
|
908 pass
|
|
|
909
|
|
|
910 def on_rclick(self,evt):
|
|
|
911 pass
|
|
|
912
|
|
|
913 def on_ldclick(self,evt):
|
|
|
914 return
|
|
|
915
|
|
|
916 def on_html(self,evt):
|
|
|
917 html_str = self.tohtml()
|
|
|
918 wnd = http_html_window(self.frame.note,-1)
|
|
|
919 wnd.title = self.xml.get('name')
|
|
|
920 self.frame.add_panel(wnd)
|
|
|
921 wnd.SetPage(html_str)
|
|
|
922
|
|
|
923 def get_design_panel(self,parent):
|
|
|
924 pass
|
|
|
925
|
|
|
926 def get_use_panel(self,parent):
|
|
|
927 return self.get_design_panel(parent)
|
|
|
928
|
|
|
929 def delete(self):
|
|
|
930 pass
|
|
|
931
|
|
|
932 class dnd3eskill(skills_char_child):
|
|
|
933 """ Node Handler for skill. This handler will be
|
|
|
934 created by dnd3echar_handler.
|
|
|
935 """
|
|
|
936 def __init__(self,xml_dom,tree_node,parent):
|
|
|
937 self.hparent = parent
|
|
|
938 self.root = getRoot(self)
|
|
|
939 self.root.skills = self
|
|
|
940
|
|
|
941 skills_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
942 tree = self.tree
|
|
|
943 icons = self.tree.icons
|
|
|
944 node_list = self.xml.findall('skill')
|
|
|
945
|
|
|
946 self.skills={}
|
|
|
947 for n in node_list:
|
|
|
948 name = n.get('name')
|
|
|
949 self.skills[name] = n
|
|
|
950 skill_check = self.skills[name]
|
|
|
951 ranks = int(skill_check.get('rank'))
|
|
|
952 trained = int(skill_check.get('untrained'))
|
|
|
953 if ranks > 0 or trained == 1:
|
|
|
954 new_tree_node = tree.AppendItem(self.mytree_node,name,
|
|
|
955 icons['gear'],icons['gear'])
|
|
|
956 else: continue
|
|
|
957 tree.SetPyData(new_tree_node,self)
|
|
|
958
|
|
|
959
|
|
|
960 def refresh_skills(self):
|
|
|
961 #Adding this so when you update the grid the tree will reflect
|
|
|
962 #The change. -mgt
|
|
|
963 tree = self.tree
|
|
|
964 icons = self.tree.icons
|
|
|
965 tree.CollapseAndReset(self.mytree_node)
|
|
|
966 node_list = self.xml.findall('skill')
|
|
|
967 self.skills={}
|
|
|
968 for n in node_list:
|
|
|
969 name = n.get('name')
|
|
|
970 self.skills[name] = n
|
|
|
971 skill_check = self.skills[name]
|
|
|
972 ranks = int(skill_check.get('rank'))
|
|
|
973 trained = int(skill_check.get('untrained'))
|
|
|
974 if ranks > 0 or trained == 1:
|
|
|
975 new_tree_node = tree.AppendItem(self.mytree_node,name,
|
|
|
976 icons['gear'],icons['gear'])
|
|
|
977 else: continue
|
|
|
978 tree.SetPyData(new_tree_node,self)
|
|
|
979
|
|
|
980 def get_mod(self,name):
|
|
|
981 skill = self.skills[name]
|
|
|
982 stat = skill.get('stat')
|
|
|
983 stat_mod = self.root.abilities.get_mod(stat)
|
|
|
984 rank = int(skill.get('rank'))
|
|
|
985 misc = int(skill.get('misc'))
|
|
|
986 total = stat_mod + rank + misc
|
|
|
987 return total
|
|
|
988
|
|
|
989 def on_rclick(self,evt):
|
|
|
990 item = self.tree.GetSelection()
|
|
|
991 name = self.tree.GetItemText(item)
|
|
|
992 if item == self.mytree_node: return
|
|
|
993 ac = self.root.ac.get_check_pen()
|
|
|
994 skill = self.skills[name]
|
|
|
995 untr = skill.get('untrained')
|
|
|
996 rank = skill.get('rank')
|
|
|
997 if eval('%s == 0' % (untr)):
|
|
|
998 if eval('%s == 0' % (rank)):
|
|
|
999 res = 'You fumble around, accomplishing nothing'
|
|
|
1000 txt = '%s Skill Check: %s' % (name, res)
|
|
|
1001 chat = self.chat
|
|
|
1002 chat.Post(txt,True,True)
|
|
|
1003 return
|
|
|
1004 armor = ''
|
|
|
1005 acCp = ''
|
|
|
1006 if ac < 0:
|
|
|
1007 armorCheck = int(skill.get('armorcheck'))
|
|
|
1008 if armorCheck == 1:
|
|
|
1009 acCp=ac
|
|
|
1010 armor = '(includes Armor Penalty of %s)' % (acCp)
|
|
|
1011 if item == self.mytree_node:
|
|
|
1012 dnd3e_char_child.on_ldclick(self,evt)
|
|
|
1013 else:
|
|
|
1014 mod = self.get_mod(name)
|
|
|
1015 if mod >= 0: mod1 = "+"
|
|
|
1016 else: mod1 = ""
|
|
|
1017 chat = self.chat
|
|
|
1018 txt = '%s Skill Check: [1d20%s%s%s] %s' % (
|
|
|
1019 name, mod1, mod, acCp, armor)
|
|
36
|
1020 Parse.Post( txt, self.chat, True, True )
|
|
28
|
1021
|
|
|
1022 def get_design_panel(self,parent):
|
|
|
1023 wnd = outline_panel(parent,self,skill_grid,"Skills")
|
|
|
1024 wnd.title = "Skills (edit)"
|
|
|
1025 return wnd
|
|
|
1026
|
|
|
1027 def tohtml(self):
|
|
|
1028 html_str = """<table border='1' width=100% ><tr BGCOLOR=#E9E9E9 >
|
|
|
1029 <th width='30%'>Skill</th><th>Key</th>
|
|
|
1030 <th>Rank</th><th>Abil</th><th>Misc</th><th>Total</th></tr>"""
|
|
|
1031 node_list = self.xml.findall('skill')
|
|
|
1032
|
|
|
1033 for n in node_list:
|
|
|
1034 name = n.get('name')
|
|
|
1035 stat = n.get('stat')
|
|
|
1036 rank = n.get('rank')
|
|
|
1037 untr = n.get('untrained')
|
|
|
1038 #Filter unsuable skills out of pretty print -mgt
|
|
|
1039 if eval('%s > 0' % (rank)) or eval('%s == 1' % (untr)):
|
|
|
1040 if eval('%s >=1' % (rank)):
|
|
|
1041 html_str += "<tr ALIGN='center' bgcolor='#CCCCFF'><td>"
|
|
|
1042 html_str += name+"</td><td>"+stat+"</td><td>"+rank+"</td>"
|
|
|
1043 elif eval('%s == 1' % (untr)):
|
|
|
1044 html_str += "<tr ALIGN='center' bgcolor='#C0FF40'><td>"
|
|
|
1045 html_str += name+"</td><td>"+stat+"</td><td>"+rank+"</td>"
|
|
|
1046 else:
|
|
|
1047 html_str += "<tr ALIGN='center'><td>"+name+"</td><td>"
|
|
|
1048 html_str += stat+"</td><td>"+rank+"</td>"
|
|
|
1049 else: continue
|
|
|
1050 stat_mod = self.root.abilities.get_mod(stat)
|
|
|
1051 misc = n.get('misc')
|
|
|
1052 mod = str(self.get_mod(name))
|
|
|
1053 if mod >= 0: mod1 = "+"
|
|
|
1054 else: mod1 = ""
|
|
|
1055 html_str += "<td>"+str(stat_mod)+"</td><td>"+misc #m 1.6009 str()
|
|
|
1056 html_str += '</td><td>%s%s</td></tr>' % (mod1, mod)
|
|
|
1057 html_str = html_str + "</table>"
|
|
|
1058 return html_str
|
|
|
1059
|
|
|
1060
|
|
|
1061 class skill_grid(wx.grid.Grid):
|
|
|
1062 """ panel for skills """
|
|
|
1063 def __init__(self, parent, handler):
|
|
|
1064 self.hparent = handler
|
|
|
1065 self.root = getRoot(self)
|
|
|
1066 pname = handler.xml.set("name", 'Skills')
|
|
|
1067
|
|
|
1068 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1069 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1070 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1071 self.handler = handler
|
|
|
1072 skills = handler.xml.findall('skill')
|
|
|
1073
|
|
|
1074 self.CreateGrid(len(skills),6)
|
|
|
1075 self.SetRowLabelSize(0)
|
|
|
1076 col_names = ['Skill','Key','Rank','Abil','Misc','Total']
|
|
|
1077 for i in range(len(col_names)):
|
|
|
1078 self.SetColLabelValue(i,col_names[i])
|
|
|
1079 rowi = 0
|
|
|
1080 self.skills = skills
|
|
|
1081 for i in range(len(skills)): self.refresh_row(i)
|
|
|
1082
|
|
|
1083 def on_cell_change(self,evt):
|
|
|
1084 row = evt.GetRow()
|
|
|
1085 col = evt.GetCol()
|
|
|
1086 value = self.GetCellValue(row,col)
|
|
|
1087 try:
|
|
|
1088 int(value)
|
|
|
1089 if col == 2: self.skills[row].set('rank',value)
|
|
|
1090 elif col ==4: self.skills[row].set('misc',value)
|
|
|
1091 self.refresh_row(row)
|
|
|
1092 except: self.SetCellValue(row,col,"0")
|
|
|
1093 self.handler.refresh_skills()
|
|
|
1094
|
|
|
1095 def refresh_row(self,rowi):
|
|
|
1096 s = self.skills[rowi]
|
|
|
1097 name = s.get('name')
|
|
|
1098 self.SetCellValue(rowi,0,name)
|
|
|
1099 self.SetReadOnly(rowi,0)
|
|
|
1100 stat = s.get('stat')
|
|
|
1101 self.SetCellValue(rowi,1,stat)
|
|
|
1102 self.SetReadOnly(rowi,1)
|
|
|
1103 self.SetCellValue(rowi,2,s.get('rank'))
|
|
|
1104 if self.root.abilities: stat_mod=self.root.abilities.get_mod(stat)
|
|
|
1105 else:
|
|
|
1106 stat_mod = -6
|
|
|
1107 print "Please advise dnd3e maintainer alert 1.5002 raised"
|
|
|
1108
|
|
|
1109 self.SetCellValue(rowi,3,str(stat_mod))
|
|
|
1110 self.SetReadOnly(rowi,3)
|
|
|
1111 self.SetCellValue(rowi,4,s.get('misc'))
|
|
|
1112 mod = str(self.handler.get_mod(name))
|
|
|
1113 self.SetCellValue(rowi,5,mod)
|
|
|
1114 self.SetReadOnly(rowi,5)
|
|
|
1115
|
|
|
1116 def on_size(self,evt):
|
|
|
1117 (w,h) = self.GetClientSizeTuple()
|
|
|
1118 cols = self.GetNumberCols()
|
|
|
1119 col_w = w/(cols+2)
|
|
|
1120 self.SetColSize(0,col_w*3)
|
|
|
1121 for i in range(1,cols): self.SetColSize(i,col_w)
|
|
|
1122 evt.Skip()
|
|
|
1123 self.Refresh()
|
|
|
1124
|
|
|
1125 def refresh_data(self):
|
|
|
1126 for r in range(self.GetNumberRows()): self.refresh_row(r)
|
|
|
1127
|
|
|
1128
|
|
|
1129 class dnd3efeats(skills_char_child):
|
|
|
1130 """ Node Handler for classes. This handler will be
|
|
|
1131 created by dnd3echar_handler.
|
|
|
1132 """
|
|
|
1133 def __init__(self,xml_dom,tree_node,parent):
|
|
|
1134 skills_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
1135 self.hparent = parent
|
|
|
1136 self.root = getRoot(self)
|
|
|
1137 self.root.feats = self
|
|
|
1138
|
|
|
1139 def get_design_panel(self,parent):
|
|
|
1140 setTitle="Feats - " + self.root.general.charName
|
|
|
1141 wnd = outline_panel(parent,self,feat_panel,setTitle)
|
|
|
1142 wnd.title = "Feats"
|
|
|
1143 return wnd
|
|
|
1144
|
|
|
1145 def tohtml(self):
|
|
|
1146 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>Feats</th></tr><tr><td>"
|
|
|
1147 n_list = self.xml.getchildren()
|
|
|
1148 for n in n_list:
|
|
|
1149 html_str += n.get('name')+ ", "
|
|
|
1150 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
1151 return html_str
|
|
|
1152
|
|
|
1153 class feat_panel(wx.Panel):
|
|
|
1154 def __init__(self, parent, handler):
|
|
|
1155
|
|
|
1156 self.hparent = handler
|
|
|
1157 self.root = getRoot(self)
|
|
|
1158 pname = handler.xml.set("name", 'Feats')
|
|
|
1159 wx.Panel.__init__(self, parent, -1)
|
|
|
1160 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1161 sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
1162 sizer.Add(self.grid, 1, wx.EXPAND)
|
|
|
1163 sizer1 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
1164 sizer1.Add(wx.Button(self, 10, "Remove Feat"), 0, wx.EXPAND)
|
|
|
1165 sizer1.Add(wx.Size(10,10))
|
|
|
1166 sizer1.Add(wx.Button(self, 20, "Add Feat"), 0, wx.EXPAND)
|
|
|
1167 sizer.Add(sizer1, 0, wx.EXPAND)
|
|
|
1168 self.sizer = sizer
|
|
|
1169 self.SetSizer(self.sizer)
|
|
|
1170 self.SetAutoLayout(True)
|
|
|
1171 self.Fit()
|
|
|
1172 self.Bind(wx.EVT_BUTTON, self.on_remove, id=10)
|
|
|
1173 self.Bind(wx.EVT_BUTTON, self.on_add, id=20)
|
|
|
1174 n_list = handler.xml.getchildren()
|
|
|
1175 self.n_list = n_list
|
|
|
1176 self.xml = handler.xml
|
|
|
1177 self.grid.CreateGrid(len(n_list),3,1)
|
|
|
1178 self.grid.SetRowLabelSize(0)
|
|
|
1179 self.grid.SetColLabelValue(0,"Feat")
|
|
|
1180 self.grid.SetColLabelValue(1,"Type")
|
|
|
1181 self.grid.SetColLabelValue(2,"Reference")
|
|
|
1182 for i in range(len(n_list)): self.refresh_row(i)
|
|
|
1183 self.temp_dom = None
|
|
|
1184
|
|
|
1185 def refresh_row(self,i):
|
|
|
1186 feat = self.n_list[i]
|
|
|
1187 name = feat.get('name')
|
|
|
1188 type = feat.get('type')
|
|
|
1189 desc = feat.get('desc')
|
|
|
1190 self.grid.SetCellValue(i,0,name)
|
|
|
1191 self.grid.SetReadOnly(i,0)
|
|
|
1192 self.grid.SetCellValue(i,1,type)
|
|
|
1193 self.grid.SetReadOnly(i,1)
|
|
|
1194 self.grid.SetCellValue(i,2,desc)
|
|
|
1195 self.grid.SetReadOnly(i,2)
|
|
|
1196
|
|
|
1197 def on_remove(self,evt):
|
|
|
1198 rows = self.grid.GetNumberRows()
|
|
|
1199 for i in range(rows):
|
|
|
1200 if self.grid.IsInSelection(i,0):
|
|
|
1201 self.grid.DeleteRows(i)
|
|
|
1202 self.xml.remove(self.n_list[i])
|
|
|
1203
|
|
|
1204 def on_add(self,evt):
|
|
|
1205
|
|
|
1206 if not self.temp_dom:
|
|
|
1207 tree = parse(dir_struct["dnd3e"]+"dnd3efeats.xml")
|
|
|
1208 temp_dom = tree.getroot()
|
|
|
1209 f_list = temp_dom.findall('feat')
|
|
|
1210 opts = []
|
|
|
1211 for f in f_list:
|
|
|
1212 opts.append(f.get('name') + " - [" +
|
|
|
1213 f.get('type') + "] - " + f.get('desc'))
|
|
|
1214 dlg = wx.SingleChoiceDialog(self,'Choose Feat','Feats',opts)
|
|
|
1215 if dlg.ShowModal() == wx.ID_OK:
|
|
|
1216 i = dlg.GetSelection()
|
|
|
1217 new_node = self.xml.append(f_list[i])
|
|
|
1218 self.grid.AppendRows(1)
|
|
|
1219 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
1220 dlg.Destroy()
|
|
|
1221
|
|
|
1222
|
|
|
1223 def on_size(self,event):
|
|
|
1224 s = self.GetClientSizeTuple()
|
|
|
1225 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
1226 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
1227 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
1228 cols = self.grid.GetNumberCols()
|
|
|
1229 col_w = w/(cols)
|
|
|
1230 for i in range(0,cols):
|
|
|
1231 self.grid.SetColSize(i,col_w)
|
|
|
1232
|
|
|
1233 class dnd3ecombat(dnd3e_char_child):
|
|
|
1234 """ Node handler for a dnd3e charactor
|
|
|
1235 <nodehandler name='?' module='dnd3e' class='dnd3echar_handler2' />
|
|
|
1236 """
|
|
|
1237 def __init__(self,xml_dom,tree_node,parent):
|
|
|
1238
|
|
|
1239 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
1240
|
|
|
1241 self.hparent = parent
|
|
|
1242 self.root = getRoot(self)
|
|
|
1243 dnd3e_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
1244 self.frame = component.get('frame')
|
|
|
1245 self.child_handlers = {}
|
|
|
1246 self.new_child_handler('hp','Hit Points',dnd3ehp,'gear')
|
|
|
1247 self.new_child_handler('attacks','Attacks',dnd3eattacks,'spears')
|
|
|
1248 self.new_child_handler('ac','Armor',dnd3earmor,'spears')
|
|
|
1249 self.myeditor = None
|
|
|
1250
|
|
|
1251 def new_child_handler(self,tag,text,handler_class,icon='gear'):
|
|
|
1252 node_list = self.xml.findall(tag)
|
|
|
1253 tree = self.tree
|
|
|
1254 i = self.tree.icons[icon]
|
|
|
1255 new_tree_node = tree.AppendItem(self.mytree_node,text,i,i)
|
|
|
1256 handler = handler_class(node_list[0],new_tree_node,self)
|
|
|
1257 tree.SetPyData(new_tree_node,handler)
|
|
|
1258 self.child_handlers[tag] = handler
|
|
|
1259
|
|
|
1260 def get_design_panel(self,parent):
|
|
|
1261 return tabbed_panel(parent,self,1)
|
|
|
1262
|
|
|
1263 def get_use_panel(self,parent):
|
|
|
1264 return tabbed_panel(parent,self,2)
|
|
|
1265
|
|
|
1266
|
|
|
1267 class combat_char_child(node_handler):
|
|
|
1268 """ Node Handler for combat. This handler will be
|
|
|
1269 created by dnd3echar_handler.
|
|
|
1270 """
|
|
|
1271 def __init__(self,xml_dom,tree_node,parent):
|
|
|
1272 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
1273 self.char_hander = parent
|
|
|
1274 self.drag = False
|
|
|
1275 self.frame = component.get('frame')
|
|
|
1276 self.myeditor = None
|
|
|
1277
|
|
|
1278 def on_drop(self,evt):
|
|
|
1279 pass
|
|
|
1280
|
|
|
1281 def on_rclick(self,evt):
|
|
|
1282 pass
|
|
|
1283
|
|
|
1284 def on_ldclick(self,evt):
|
|
|
1285 return
|
|
|
1286
|
|
|
1287 def on_html(self,evt):
|
|
|
1288 html_str = self.tohtml()
|
|
|
1289 wnd = http_html_window(self.frame.note,-1)
|
|
|
1290 wnd.title = self.xml.get('name')
|
|
|
1291 self.frame.add_panel(wnd)
|
|
|
1292 wnd.SetPage(html_str)
|
|
|
1293
|
|
|
1294 def get_design_panel(self,parent):
|
|
|
1295 pass
|
|
|
1296
|
|
|
1297 def get_use_panel(self,parent):
|
|
|
1298 return self.get_design_panel(parent)
|
|
|
1299
|
|
|
1300 def delete(self):
|
|
|
1301 pass
|
|
|
1302
|
|
|
1303 class dnd3ehp(combat_char_child):
|
|
|
1304 """ Node Handler for hit points. This handler will be
|
|
|
1305 created by dnd3echar_handler.
|
|
|
1306 """
|
|
|
1307 def __init__(self,xml_dom,tree_node,parent):
|
|
|
1308 combat_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
1309 self.hparent = parent
|
|
|
1310 self.root = getRoot(self)
|
|
|
1311 self.root.hp = self
|
|
|
1312
|
|
|
1313 def get_design_panel(self,parent):
|
|
|
1314 wnd = outline_panel(parent,self,hp_panel,"Hit Points")
|
|
|
1315 wnd.title = "Hit Points"
|
|
|
1316 return wnd
|
|
|
1317
|
|
|
1318 def on_rclick( self, evt ):
|
|
|
1319 chp = self.xml.get('current')
|
|
|
1320 mhp = self.xml.get('max')
|
|
|
1321 txt = '((HP: %s / %s))' % ( chp, mhp )
|
|
36
|
1322 Parse.Post( txt, self.chat, True, True )
|
|
28
|
1323
|
|
|
1324 def tohtml(self):
|
|
|
1325 html_str = "<table width=100% border=1 >"
|
|
|
1326 html_str += "<tr BGCOLOR=#E9E9E9 ><th colspan=4>Hit Points</th></tr>"
|
|
|
1327 html_str += "<tr><th>Max:</th>"
|
|
|
1328 html_str += "<td>"+self.xml.get('max')+"</td>"
|
|
|
1329 html_str += "<th>Current:</th>"
|
|
|
1330 html_str += "<td>"+self.xml.get('current')+"</td>"
|
|
|
1331 html_str += "</tr></table>"
|
|
|
1332 return html_str
|
|
|
1333
|
|
|
1334 class hp_panel(wx.Panel):
|
|
|
1335 def __init__(self, parent, handler):
|
|
|
1336 wx.Panel.__init__(self, parent, -1)
|
|
|
1337 self.hparent = handler
|
|
|
1338 pname = handler.xml.set("name", 'HitPoints')
|
|
|
1339 self.sizer = wx.FlexGridSizer(2, 4, 2, 2) # rows, cols, hgap, vgap
|
|
|
1340 self.xml = handler.xml
|
|
|
1341 self.sizer.AddMany([ (wx.StaticText(self, -1, "HP Current:"), 0,
|
|
|
1342 wx.ALIGN_CENTER_VERTICAL),
|
|
|
1343 (wx.TextCtrl(self, HP_CUR,
|
|
|
1344 self.xml.get('current')), 0, wx.EXPAND),
|
|
|
1345 (wx.StaticText(self, -1, "HP Max:"), 0, wx.ALIGN_CENTER_VERTICAL),
|
|
|
1346 (wx.TextCtrl(self, HP_MAX, self.xml.get('max')),
|
|
|
1347 0, wx.EXPAND),
|
|
|
1348 ])
|
|
|
1349 self.sizer.AddGrowableCol(1)
|
|
|
1350 self.SetSizer(self.sizer)
|
|
|
1351 self.SetAutoLayout(True)
|
|
|
1352 self.Fit()
|
|
|
1353 self.Bind(wx.EVT_TEXT, self.on_text, id=HP_MAX)
|
|
|
1354 self.Bind(wx.EVT_TEXT, self.on_text, id=HP_CUR)
|
|
|
1355
|
|
|
1356 def on_text(self,evt):
|
|
|
1357 id = evt.GetId()
|
|
|
1358 if id == HP_CUR: self.xml.set('current',evt.GetString())
|
|
|
1359 elif id == HP_MAX: self.xml.set('max',evt.GetString())
|
|
|
1360
|
|
|
1361 def on_size(self,evt):
|
|
|
1362 s = self.GetClientSizeTuple()
|
|
|
1363 self.sizer.SetDimension(0,0,s[0],s[1])
|
|
|
1364
|
|
|
1365 class dnd3eattacks(combat_char_child):
|
|
|
1366 """ Node Handler for attacks. This handler will be
|
|
|
1367 created by dnd3echar_handler.
|
|
|
1368 """
|
|
|
1369 def __init__(self,xml_dom,tree_node,parent):
|
|
|
1370 combat_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
1371 self.hparent = parent
|
|
|
1372 self.root = getRoot(self)
|
|
|
1373 self.root.attacks = self
|
|
|
1374 self.mrFrame = []
|
|
|
1375 self.updateFootNotes = False
|
|
|
1376 self.updateFootNotes = False
|
|
|
1377 self.html_str = "<html><body>"
|
|
|
1378 self.html_str += ("<br> This character has weapons with no "+
|
|
|
1379 "footnotes. This program will "+
|
|
|
1380 "add footnotes to the weapons which have names that still match "+
|
|
|
1381 "the orginal names. If you have changed the weapon name, you "+
|
|
|
1382 "will see some weapons with a footnote of 'X', you will have "+
|
|
|
1383 "to either delete and re-add the weapon, or research "+
|
|
|
1384 "and add the correct footnotes for the weapon.\n"+
|
|
|
1385 "<br> Please be aware, that only the bow/sling footnote is "+
|
|
|
1386 "being used to affect changes to rolls; implemenation of other "+
|
|
|
1387 "footnotes to automaticly adjust rolls will be completed as "+
|
|
|
1388 "soon as time allows." +
|
|
|
1389 "<br><br>Update to character:"+self.root.general.charName+
|
|
|
1390 "<br><br>"+
|
|
|
1391 """<table border='1' width=100% ><tr BGCOLOR=#E9E9E9 >
|
|
|
1392 <th width='80%'>Weapon Name</th><th>Added Footnote</th></tr>\n""")
|
|
|
1393 self.temp_dom={}
|
|
|
1394 node_list = self.xml.findall('melee')
|
|
|
1395 self.melee = node_list[0]
|
|
|
1396 node_list = self.xml.findall('ranged')
|
|
|
1397 self.ranged = node_list[0]
|
|
|
1398 self.refresh_weapons()
|
|
|
1399 if self.updateFootNotes == True:
|
|
|
1400 self.updateFootNotes = False
|
|
|
1401 name = self.root.general.charName
|
|
|
1402 self.html_str += "</table>"
|
|
|
1403 self.html_str += "</body> </html> "
|
|
|
1404 masterFrame = self.root.frame
|
|
|
1405 title = name+"'s weapons' update to have footnotes"
|
|
|
1406 fnFrame = wx.Frame(masterFrame, -1, title)
|
|
|
1407 fnFrame.panel = wx.html.HtmlWindow(fnFrame,-1)
|
|
|
1408 fnFrame.panel.SetPage(self.html_str)
|
|
|
1409 fnFrame.Show()
|
|
|
1410
|
|
|
1411
|
|
|
1412
|
|
|
1413 def refreshMRdata(self):
|
|
|
1414 # of the attack chart.
|
|
|
1415 # count backwards, maintains context despite "removes"
|
|
|
1416 for i in range(len(self.mrFrame)-1,-1,-1):
|
|
|
1417 x = self.mrFrame[i]
|
|
|
1418 if x == None: x.refreshMRdata() #a 1.9001
|
|
|
1419 else: self.mrFrame.remove(x)
|
|
|
1420
|
|
|
1421 def refresh_weapons(self):
|
|
|
1422 self.weapons = {}
|
|
|
1423
|
|
|
1424 tree = self.tree
|
|
|
1425 icons = self.tree.icons
|
|
|
1426 tree.CollapseAndReset(self.mytree_node)
|
|
|
1427 node_list = self.xml.findall('weapon')
|
|
|
1428 for n in node_list:
|
|
|
1429 name = n.get('name')
|
|
|
1430 fn = safeGetAttr(n,'fn')
|
|
|
1431 if fn == None:
|
|
|
1432 self.updateFootNotes=True
|
|
|
1433 self.updateFootN(n)
|
|
|
1434 new_tree_node = tree.AppendItem(
|
|
|
1435 self.mytree_node,name,icons['sword'],icons['sword'])
|
|
|
1436 tree.SetPyData(new_tree_node,self)
|
|
|
1437 self.weapons[name]=n
|
|
|
1438
|
|
|
1439 def updateFootN(self,n):
|
|
|
1440 if not self.temp_dom:
|
|
|
1441 tree = parse(dir_struct["dnd3e"]+"dnd3eweapons.xml")
|
|
|
1442 self.temp_dom = tree.getroot()
|
|
|
1443 nameF = n.get('name')
|
|
|
1444 w_list = self.temp_dom.findall('weapon')
|
|
|
1445 found = False
|
|
|
1446 for w in w_list:
|
|
|
1447 if nameF == w.get('name'):
|
|
|
1448 found = True
|
|
|
1449 fnN = safeGetAttr(n,'fn')
|
|
|
1450 if fnN == None or fnN == 'None':
|
|
|
1451 fnW = w.get('fn')
|
|
|
1452 self.html_str += ("<tr ALIGN='center'><td>"+nameF+"</td>"+
|
|
|
1453 "<td>"+fnW+"</td></tr>\n")
|
|
|
1454 n.set('fn',fnW)
|
|
|
1455 break
|
|
|
1456 if not found:
|
|
|
1457 self.html_str += ("<tr ALIGN='center'><td>"+nameF+" - Custom "+
|
|
|
1458 "Weapon, research "+
|
|
|
1459 "and update manually; setting footnote to indicate custom</td>"+
|
|
|
1460 "<td>"+'X'+"</td></tr>\n")
|
|
|
1461 n.set('fn','X')
|
|
|
1462
|
|
|
1463 def get_mod(self,type='m'):
|
|
|
1464 (base, base2, base3, base4, base5, base6, stat_mod, misc) \
|
|
|
1465 = self.get_attack_data(type)
|
|
|
1466 return int(base + misc + int(stat_mod))
|
|
|
1467
|
|
|
1468 def get_attack_data(self,type='m'):
|
|
|
1469 if type=='m' or type=='0':
|
|
|
1470 stat = 'Str'
|
|
|
1471 temp = self.melee
|
|
|
1472 else:
|
|
|
1473 stat = 'Dex'
|
|
|
1474 temp = self.ranged
|
|
|
1475 stat_mod = -7
|
|
|
1476 stat_mod = self.root.abilities.get_mod(stat)
|
|
|
1477 base = int(temp.get('base'))
|
|
|
1478 base2 = int(temp.get('second'))
|
|
|
1479 base3 = int(temp.get('third'))
|
|
|
1480 base4 = int(temp.get('forth'))
|
|
|
1481 base5 = int(temp.get('fifth'))
|
|
|
1482 base6 = int(temp.get('sixth'))
|
|
|
1483 misc = int(temp.get('misc'))
|
|
|
1484 return (base, base2, base3, base4, base5, base6, stat_mod ,misc)
|
|
|
1485
|
|
|
1486 def on_rclick(self,evt):
|
|
|
1487 item = self.tree.GetSelection()
|
|
|
1488
|
|
|
1489 name = self.tree.GetItemText(item)
|
|
|
1490 if item == self.mytree_node:
|
|
|
1491 return
|
|
|
1492 else:
|
|
|
1493
|
|
|
1494 mod = int(self.weapons[name].get('mod'))
|
|
|
1495 wepMod = mod #a 1.5008
|
|
|
1496 footNotes = safeGetAttr(self.weapons[name],'fn','')
|
|
|
1497 cat = self.weapons[name].get('category') #a1.6001
|
|
|
1498 result = split(cat,"-",2) #a 1.6001
|
|
|
1499 if len(result) < 2: #a 1.6021 this if & else
|
|
|
1500 print "warning: 1.6002 unable to interpret weapon category"
|
|
|
1501 print "format 'type weapon-[Range|Melee]', probably missing"
|
|
|
1502 print "the hyphen. Assuming Melee"
|
|
|
1503 print "weapon name: ",name
|
|
|
1504 tres="Melee"
|
|
|
1505 else:
|
|
|
1506 tres=result[1]
|
|
|
1507 if tres == 'Melee': #a 1.6001 #m 1.6022 use of tres here and...
|
|
|
1508 rangeOrMelee = 'm' #a 1.5008 code demote for next comment block
|
|
|
1509 elif tres == 'Ranged': #m 1.6001 (was just else) #m 1.6022 here
|
|
|
1510 rangeOrMelee = 'r' #a 1.5008
|
|
|
1511 else:#a 1.6001 add this whole else clause.
|
|
|
1512 print "warning: 1.6001 unable to interpret weapon category"
|
|
|
1513 print "treating weapon as Melee, please correct xml"
|
|
|
1514 print "weapon name:",name
|
|
|
1515 rangeOrMelee ='m'
|
|
|
1516 mod = mod + self.get_mod(rangeOrMelee) #a 1.5008
|
|
|
1517 chat = self.chat
|
|
|
1518 dmg = self.weapons[name].get('damage')
|
|
|
1519
|
|
|
1520 #a 1.6003 start code fix instance a
|
|
|
1521 result = split(dmg,"/",2)
|
|
|
1522 dmg = result[0]
|
|
|
1523 monkLvl = self.root.classes.get_class_lvl('Monk') # a 1.5002
|
|
|
1524 if dmg == "Monk Med":
|
|
|
1525 if monkLvl == None: #a 1.5009
|
|
|
1526 txt = 'Attempting to use monk attack, but has no monk '
|
|
|
1527 txt += 'levels, please choose a different attack.'
|
|
36
|
1528 Parse.Post( txt, self.chat, True, True )
|
|
28
|
1529 return #a 1.5009
|
|
|
1530 else: #a 1.5009
|
|
|
1531 lvl=int(monkLvl)
|
|
|
1532 if lvl <= 3: dmg = "1d6"
|
|
|
1533 elif lvl <= 7: dmg = "1d8"
|
|
|
1534 elif lvl <= 11: dmg = "1d10"
|
|
|
1535 elif lvl <= 15: dmg = "2d6"
|
|
|
1536 elif lvl <= 19: dmg = "2d8"
|
|
|
1537 elif lvl <= 20: dmg = "2d10"
|
|
|
1538 if dmg == "Monk Small":
|
|
|
1539 if monkLvl == None:
|
|
|
1540 txt = 'Attempting to use monk attack, but has no monk '
|
|
|
1541 txt += 'levels, please choose a different attack.'
|
|
36
|
1542 Parse.Post( txt, self.chat, True, True )
|
|
28
|
1543 return
|
|
|
1544 else:
|
|
|
1545 lvl=int(monkLvl)
|
|
|
1546 if lvl <= 3: dmg = "1d4"
|
|
|
1547 elif lvl <= 7: dmg = "1d6"
|
|
|
1548 elif lvl <= 11: dmg = "1d8"
|
|
|
1549 elif lvl <= 15: dmg = "1d10"
|
|
|
1550 elif lvl <= 20: dmg = "2d6"
|
|
|
1551 flu = ''
|
|
|
1552 str_mod = self.root.abilities.get_mod('Str') #a 1.5007,11,12,13
|
|
|
1553 if rangeOrMelee == 'r': #a 1.5008
|
|
|
1554
|
|
|
1555 if find(footNotes,'b') > -1:
|
|
|
1556 if str_mod >= 0: str_mod = 0
|
|
|
1557 else: str_mod = 0
|
|
|
1558 mod2 = ""
|
|
|
1559 if str_mod >= 0: mod2 = "+"
|
|
|
1560 aStrengthMod = mod2 + str(str_mod) #a 1.5008 applicable strength mod
|
|
|
1561 if find(name ,"Flurry of Blows") > -1: #a 1.6012
|
|
|
1562 flu = '-2'
|
|
|
1563 (base, base2, base3, base4, base5, base6, stat_mod, misc)\
|
|
|
1564 = self.get_attack_data(rangeOrMelee) #a 1.5008
|
|
|
1565 self.sendRoll(base ,stat_mod,misc,wepMod,name,flu,dmg,
|
|
|
1566 aStrengthMod,'',True,rollAnyWay=True)
|
|
|
1567 if flu != '':
|
|
|
1568 self.sendRoll(base ,stat_mod,misc,wepMod,name,flu,dmg,
|
|
|
1569 aStrengthMod) #a 1.6021
|
|
|
1570
|
|
|
1571 self.sendRoll(base2,stat_mod,misc,wepMod,name,flu,dmg,aStrengthMod)
|
|
|
1572 self.sendRoll(base3,stat_mod,misc,wepMod,name,flu,dmg,aStrengthMod)
|
|
|
1573 self.sendRoll(base4,stat_mod,misc,wepMod,name,flu,dmg,aStrengthMod)
|
|
|
1574 self.sendRoll(base5,stat_mod,misc,wepMod,name,flu,dmg,aStrengthMod)
|
|
|
1575 self.sendRoll(base6,stat_mod,misc,wepMod,name,flu,dmg,aStrengthMod)
|
|
|
1576
|
|
|
1577
|
|
|
1578 def sendRoll(self,base,stat_mod,misc,wepMod,name,flu,dmg,aStrengthMod,
|
|
|
1579 spacer="",pname=False,rollAnyWay=False):
|
|
|
1580 if base != 0 or rollAnyWay:
|
|
|
1581 base = base + int(stat_mod) + misc + wepMod #m 1.5008
|
|
|
1582 if base >= 0: mod1 = "+"
|
|
|
1583 else: mod1 = ""
|
|
|
1584 txt = '%s ' % (spacer)
|
|
|
1585 txt += '%s Attack Roll: <b>[1d20%s%s%s]</b>' % (name, mod1, base, flu)
|
|
|
1586 txt += ' ===> Damage: <b>[%s%s]</b>' % (dmg, aStrengthMod)
|
|
36
|
1587 Parse.Post( txt, self.chat, True, True )
|
|
28
|
1588
|
|
|
1589 def get_design_panel(self,parent):
|
|
|
1590 wnd = outline_panel(parent,self,attack_panel,"Attacks")
|
|
|
1591 wnd.title = "Attacks"
|
|
|
1592 return wnd
|
|
|
1593
|
|
|
1594 def tohtml(self):
|
|
|
1595 melee = self.get_attack_data('m')
|
|
|
1596 ranged = self.get_attack_data('r')
|
|
|
1597 html_str = ("""<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 >"""+
|
|
|
1598 "<th>Attack</th><th>Total</th><th >Base</th>"+
|
|
|
1599 "<th>Abil</th><th>Misc</th></tr>")
|
|
|
1600 html_str += "<tr ALIGN='center' ><th >Melee:</th>"
|
|
|
1601 html_str += "<td>"+str(melee[0]+melee[1]+melee[2])+"</td>"
|
|
|
1602 html_str += "<td>"+str(melee[0])+"</td>"
|
|
|
1603 html_str += "<td>"+str(melee[1])+"</td>"
|
|
|
1604 html_str += "<td>"+str(melee[2])+"</td></tr>"
|
|
|
1605
|
|
|
1606 html_str += "<tr ALIGN='center' ><th >Ranged:</th>"
|
|
|
1607 html_str += "<td>"+str(ranged[0]+ranged[1]+ranged[2])+"</td>"
|
|
|
1608 html_str += "<td>"+str(ranged[0])+"</td>"
|
|
|
1609 html_str += "<td>"+str(ranged[1])+"</td>"
|
|
|
1610 html_str += "<td>"+str(ranged[2])+"</td></tr></table>"
|
|
|
1611
|
|
|
1612 n_list = self.xml.findall('weapon')
|
|
|
1613 for n in n_list:
|
|
|
1614 mod = n.get('mod')
|
|
|
1615 if mod >= 0: mod1 = "+"
|
|
|
1616 else: mod1 = ""
|
|
|
1617 ran = n.get('range')
|
|
|
1618 total = str(int(mod) + self.get_mod(ran))
|
|
|
1619 html_str += """<P><table width=100% border=1 ><tr BGCOLOR=#E9E9E9 >
|
|
|
1620 <th colspan=2>Weapon</th>
|
|
|
1621 <th>Attack</th><th >Damage</th><th>Critical</th></tr>"""
|
|
|
1622 html_str += "<tr ALIGN='center' ><td colspan=2>"
|
|
|
1623 html_str += n.get('name')+"</td><td>"+total+"</td>"
|
|
|
1624 html_str += "<td>"+n.get('damage')+"</td><td>"
|
|
|
1625 html_str += n.get('critical')+"</td></tr>"
|
|
|
1626 html_str += """<tr BGCOLOR=#E9E9E9 ><th>Range</th><th>Weight</th>
|
|
|
1627 <th>Type</th><th>Size</th><th>Misc Mod</th></tr>"""
|
|
|
1628 html_str += "<tr ALIGN='center'><td>"+ran+"</td><td>"
|
|
|
1629 html_str += n.get('weight')+"</td>"
|
|
|
1630 html_str += "<td>"+n.get('type')+"</td><td>"
|
|
|
1631 html_str += n.get('size')+"</td>"
|
|
|
1632 html_str += '<td>%s%s</td></tr>' % (mod1, mod)
|
|
|
1633 html_str += """<tr><th BGCOLOR=#E9E9E9 colspan=2>Footnotes:</th>"""
|
|
|
1634 html_str += "<th colspan=3>"+safeGetAttr(n,'fn','')+"</th></tr>"
|
|
|
1635 html_str += '</table>'
|
|
|
1636 return html_str
|
|
|
1637
|
|
|
1638 class attack_grid(wx.grid.Grid):
|
|
|
1639 """grid for attacks"""
|
|
|
1640 def __init__(self, parent, handler):
|
|
|
1641 pname = handler.xml.set("name", 'Melee')
|
|
|
1642 self.hparent = handler
|
|
|
1643 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1644
|
|
|
1645 self.root = getRoot(self) #a 1.9001
|
|
|
1646 self.parent = parent
|
|
|
1647 self.handler = handler
|
|
|
1648 self.rows = (self.handler.melee,self.handler.ranged)
|
|
|
1649 self.CreateGrid(2,10)
|
|
|
1650 self.SetRowLabelSize(0)
|
|
|
1651 col_names = ['Type','base','base 2','base 3','base 4','base 5',
|
|
|
1652 'base 6','abil','misc','Total']
|
|
|
1653 for i in range(len(col_names)): self.SetColLabelValue(i,col_names[i])
|
|
|
1654 self.SetCellValue(0,0,"Melee")
|
|
|
1655 self.SetCellValue(1,0,"Ranged")
|
|
|
1656 self.refresh_data()
|
|
|
1657 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1658 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1659 climber = parent
|
|
|
1660 nameNode = climber.GetClassName()
|
|
|
1661 while nameNode != 'wxFrame':
|
|
|
1662 climber = climber.parent
|
|
|
1663 nameNode = climber.GetClassName()
|
|
|
1664 masterFrame=climber
|
|
|
1665 masterFrame.refreshMRdata=self.refresh_data
|
|
|
1666 handler.mrFrame.append(masterFrame)
|
|
|
1667
|
|
|
1668
|
|
|
1669 def on_cell_change(self,evt):
|
|
|
1670 row = evt.GetRow()
|
|
|
1671 col = evt.GetCol()
|
|
|
1672 value = self.GetCellValue(row,col)
|
|
|
1673 try:
|
|
|
1674 int(value)
|
|
|
1675 if col==1: self.rows[row].set('base',value)
|
|
|
1676 elif col==2: self.rows[row].set('second',value)
|
|
|
1677 elif col==3: self.rows[row].set('third',value)
|
|
|
1678 elif col==4: self.rows[row].set('forth',value)
|
|
|
1679 elif col==5: self.rows[row].set('fifth',value)
|
|
|
1680 elif col==6: self.rows[row].set('sixth',value)
|
|
|
1681 elif col==8: self.rows[row].set('misc',value)
|
|
|
1682 self.parent.refresh_data()
|
|
|
1683 except: self.SetCellValue(row,col,"0")
|
|
|
1684
|
|
|
1685 def refresh_data(self):
|
|
|
1686 melee = self.handler.get_attack_data('m')
|
|
|
1687 ranged = self.handler.get_attack_data('r')
|
|
|
1688 tmelee = int(melee[0]) + int(melee[6]) + int(melee[7])
|
|
|
1689 tranged = int(ranged[0]) + int(ranged[6]) + int(ranged[7])
|
|
|
1690 for i in range(0,8): #a 1.5005
|
|
|
1691 self.SetCellValue(0,i+1,str(melee[i]))
|
|
|
1692 self.SetCellValue(1,i+1,str(ranged[i]))
|
|
|
1693 self.SetCellValue(0,9,str(tmelee))
|
|
|
1694 self.SetCellValue(1,9,str(tranged))
|
|
|
1695 self.SetReadOnly(0,0)
|
|
|
1696 self.SetReadOnly(1,0)
|
|
|
1697 self.SetReadOnly(0,7)
|
|
|
1698 self.SetReadOnly(1,7)
|
|
|
1699 self.SetReadOnly(0,9)
|
|
|
1700 self.SetReadOnly(1,9)
|
|
|
1701
|
|
|
1702 def on_size(self,evt):
|
|
|
1703 (w,h) = self.GetClientSizeTuple()
|
|
|
1704 cols = self.GetNumberCols()
|
|
|
1705 col_w = w/(cols+1)
|
|
|
1706 self.SetColSize(0,col_w*2)
|
|
|
1707 for i in range(1,cols): self.SetColSize(i,col_w)
|
|
|
1708 evt.Skip()
|
|
|
1709 self.Refresh()
|
|
|
1710
|
|
|
1711 class weapon_panel(wx.Panel):
|
|
|
1712 def __init__(self, parent, handler):
|
|
|
1713 self.hparent = handler
|
|
|
1714 self.root = getRoot(self)
|
|
|
1715 pname = handler.xml.set("name", 'Weapons')
|
|
|
1716 wx.Panel.__init__(self, parent, -1)
|
|
|
1717 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1718 sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
1719 sizer.Add(self.grid, 1, wx.EXPAND)
|
|
|
1720 sizer2 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
1721 sizer2.Add(wx.Button(self, 10, "Remove Weapon"), 0, wx.EXPAND)
|
|
|
1722 sizer2.Add(wx.Size(10,10))
|
|
|
1723 sizer2.Add(wx.Button(self, 20, "Add Weapon"), 0, wx.EXPAND)
|
|
|
1724 sizer.Add(sizer2, 0, wx.EXPAND)
|
|
|
1725 sizer.Add(wx.StaticText(self, -1, "Right click a weapon's footnote to see what the footnotes mean."),0, wx.EXPAND)#a 1.5012
|
|
|
1726 self.sizer = sizer
|
|
|
1727 self.SetSizer(self.sizer)
|
|
|
1728 self.SetAutoLayout(True)
|
|
|
1729 self.Fit()
|
|
|
1730 self.sizer2 = sizer2
|
|
|
1731 self.Bind(wx.EVT_BUTTON, self.on_remove, id=10)
|
|
|
1732 self.Bind(wx.EVT_BUTTON, self.on_add, id=20)
|
|
|
1733 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1734 self.grid.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self.on_gridRclick)#a 1.5012
|
|
|
1735
|
|
|
1736 n_list = handler.xml.findall('weapon')
|
|
|
1737 self.n_list = n_list
|
|
|
1738 self.xml = handler.xml
|
|
|
1739 self.handler = handler
|
|
|
1740 self.colAttr = ['name','damage','mod','critical','type','weight',
|
|
|
1741 'range','size','Total','fn', 'comment']
|
|
|
1742 col_names = ['Name','Damage','To hit\nmod','Critical','Type','Weight',
|
|
|
1743 'Range','Size','Total','Foot\nnotes','Comment']
|
|
|
1744 gridColCount=len(col_names)
|
|
|
1745 self.grid.CreateGrid(len(n_list),gridColCount,1)
|
|
|
1746 self.grid.SetRowLabelSize(0)
|
|
|
1747 for i in range(gridColCount): self.grid.SetColLabelValue(i,col_names[i])
|
|
|
1748 self.refresh_data()
|
|
|
1749 self.temp_dom = None
|
|
|
1750
|
|
|
1751
|
|
|
1752 #mark4
|
|
|
1753 #a 1.5012 add entire method.
|
|
|
1754 def on_gridRclick(self,evt):
|
|
|
1755 row = evt.GetRow()
|
|
|
1756 col = evt.GetCol()
|
|
|
1757 value = self.grid.GetCellValue(row,col)
|
|
|
1758 if col == 9 and value != 'None':
|
|
|
1759 n = self.n_list[row]
|
|
|
1760 name = n.get('name')
|
|
|
1761 handler = self.hparent
|
|
|
1762 # A handler is a node, and nodes have a reference to
|
|
|
1763 # the master frame
|
|
|
1764 masterFrame = handler.frame
|
|
|
1765 title = name+"'s Special Weapon Characteristics"
|
|
|
1766 fnFrame = wx.Frame(masterFrame, -1, title)
|
|
|
1767 fnFrame.panel = wx.html.HtmlWindow(fnFrame,-1)
|
|
|
1768 if not self.temp_dom:
|
|
|
1769 tree = parse(dir_struct["dnd3e"]+"dnd3eweapons.xml")
|
|
|
1770 xml_dom = tree.getroot()
|
|
|
1771 self.temp_dom = xml_dom
|
|
|
1772 f_list = self.temp_dom.findall('f') # the footnotes
|
|
|
1773 n = self.n_list[row]
|
|
|
1774 name = n.get('name')
|
|
|
1775 footnotes = n.get('fn')
|
|
|
1776 html_str = "<html><body>"
|
|
|
1777 html_str += """<table border='1' width=100% ><tr BGCOLOR=#E9E9E9 >
|
|
|
1778 <th width='10%'>Note</th><th>Description</th></tr>\n"""
|
|
|
1779 if footnotes == "":
|
|
|
1780 html_str += "<tr ALIGN='center'><td></td>"
|
|
|
1781 html_str += " <td>This weapon has no footnotes</td></tr>"
|
|
|
1782 for i in range(len(footnotes)):
|
|
|
1783 aNote=footnotes[i]
|
|
|
1784 found=False
|
|
|
1785 for f in f_list:
|
|
|
1786 if f.get('mark') == aNote:
|
|
|
1787 found=True
|
|
|
1788 text=f.get('txt')
|
|
|
1789 html_str += ("<tr ALIGN='center'><td>"+aNote+"</td>"+
|
|
|
1790 "<td>"+text+"</td></tr>\n")
|
|
|
1791 if not found:
|
|
|
1792 html_str += ("<tr ALIGN='center'><td>"+aNote+"</td>"+
|
|
|
1793 "<td>is not a recognized footnote</td></tr>\n")
|
|
|
1794
|
|
|
1795 html_str += "</table>"
|
|
|
1796 html_str += "</body> </html> "
|
|
|
1797 fnFrame.panel.SetPage(html_str)
|
|
|
1798 fnFrame.Show()
|
|
|
1799 return
|
|
|
1800 pass
|
|
|
1801
|
|
|
1802
|
|
|
1803 def on_cell_change(self,evt):
|
|
|
1804 row = evt.GetRow()
|
|
|
1805 col = evt.GetCol()
|
|
|
1806 value = self.grid.GetCellValue(row,col)
|
|
|
1807 if col == 2 and not int(value): # special case for mod, demoted
|
|
|
1808 value = "0" #a 5.012 demoted
|
|
|
1809 self.n_list[row].set('mod',value) # a 5.012 demoted
|
|
|
1810 if not (col == 9 and value == "None" and
|
|
|
1811 self.n_list[row].get('fn') == "None"
|
|
|
1812 ): #a 5.012 special case for footnotes
|
|
|
1813 self.n_list[row].set(self.colAttr[col],value)#a 5.012
|
|
|
1814
|
|
|
1815
|
|
|
1816 def refresh_row(self,i):
|
|
|
1817 n = self.n_list[i]
|
|
|
1818 fn = n.get('fn')
|
|
|
1819 name = n.get('name')
|
|
|
1820 mod = n.get('mod')
|
|
|
1821 ran = n.get('range')
|
|
|
1822 total = str(int(mod) + self.handler.get_mod(ran))
|
|
|
1823 self.grid.SetCellValue(i,0,name)
|
|
|
1824 self.grid.SetCellValue(i,1,n.get('damage'))
|
|
|
1825 self.grid.SetCellValue(i,2,mod)
|
|
|
1826 self.grid.SetCellValue(i,3,n.get('critical'))
|
|
|
1827 self.grid.SetCellValue(i,4,n.get('type'))
|
|
|
1828 self.grid.SetCellValue(i,5,n.get('weight'))
|
|
|
1829 self.grid.SetCellValue(i,6,ran)
|
|
|
1830 self.grid.SetCellValue(i,7,n.get('size') )
|
|
|
1831 self.grid.SetCellValue(i,8,total)
|
|
|
1832 self.grid.SetCellValue(i,9,safeGetAttr(n,'fn','None')) #a 1.5012
|
|
|
1833 self.grid.SetCellValue(i,10,safeGetAttr(n,'comment','')) #a 1.5012
|
|
|
1834 self.grid.SetReadOnly(i,8)
|
|
|
1835
|
|
|
1836 def on_remove(self,evt): #o 1.6011 correcting wrongful deletion
|
|
|
1837 rows = self.grid.GetNumberRows()
|
|
|
1838 for i in range(rows-1,-1,-1): #a 1.6011 or you lose context
|
|
|
1839 if self.grid.IsInSelection(i,0):
|
|
|
1840 self.grid.DeleteRows(i)
|
|
|
1841 self.xml.remove(self.n_list[i])
|
|
|
1842 self.n_list = self.xml.findall('weapon')
|
|
|
1843 self.handler.refresh_weapons()
|
|
|
1844
|
|
|
1845 def on_add(self,evt):
|
|
|
1846 if not self.temp_dom:
|
|
|
1847 tree = parse(dir_struct["dnd3e"]+"dnd3eweapons.xml")
|
|
|
1848 xml_dom = tree.getroot()
|
|
|
1849 self.temp_dom = xml_dom
|
|
|
1850 f_list = self.temp_dom.findall('weapon')
|
|
|
1851 opts = []
|
|
|
1852 for f in f_list:
|
|
|
1853 opts.append(f.get('name'))
|
|
|
1854 dlg = wx.SingleChoiceDialog(self,'Choose Weapon','Weapon List',opts)
|
|
|
1855 if dlg.ShowModal() == wx.ID_OK:
|
|
|
1856 i = dlg.GetSelection()
|
|
|
1857 new_node = self.xml.append(f_list[i])
|
|
|
1858 self.grid.AppendRows(1)
|
|
|
1859 self.n_list = self.xml.findall('weapon')
|
|
|
1860 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
1861 self.handler.refresh_weapons()
|
|
|
1862 dlg.Destroy()
|
|
|
1863
|
|
|
1864 def on_size(self,event):
|
|
|
1865 s = self.GetClientSizeTuple()
|
|
|
1866 self.grid.SetDimensions(0,0,s[0],s[1]-40)
|
|
|
1867 self.sizer.SetDimension(0,s[1]-40,s[0],25)
|
|
|
1868 self.sizer2.SetDimension(0,s[1]-15,s[0],15)
|
|
|
1869 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
1870 cols = self.grid.GetNumberCols()
|
|
|
1871 col_w = w/(cols+1)
|
|
|
1872 self.grid.SetColSize(0,col_w*2)
|
|
|
1873 for i in range(1,cols): self.grid.SetColSize(i,col_w)
|
|
|
1874
|
|
|
1875 def refresh_data(self):
|
|
|
1876 for i in range(len(self.n_list)): self.refresh_row(i)
|
|
|
1877
|
|
|
1878
|
|
|
1879 class attack_panel(wx.Panel):
|
|
|
1880 def __init__(self, parent, handler):
|
|
|
1881 pname = handler.xml.set("name", 'Melee')
|
|
|
1882 self.parent = parent #a 1.9001
|
|
|
1883 wx.Panel.__init__(self, parent, -1)
|
|
|
1884 self.a_grid = attack_grid(self, handler)
|
|
|
1885 self.w_panel = weapon_panel(self, handler)
|
|
|
1886 self.sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
1887 self.sizer.Add(self.a_grid, 1, wx.EXPAND)
|
|
|
1888 self.sizer.Add(self.w_panel, 2, wx.EXPAND)
|
|
|
1889 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1890
|
|
|
1891 def on_size(self,event):
|
|
|
1892 s = self.GetClientSizeTuple()
|
|
|
1893 self.sizer.SetDimension(0,0,s[0],s[1])
|
|
|
1894
|
|
|
1895 def refresh_data(self):
|
|
|
1896 self.w_panel.refresh_data()
|
|
|
1897 self.a_grid.refresh_data()
|
|
|
1898
|
|
|
1899
|
|
|
1900 class dnd3earmor(combat_char_child):
|
|
|
1901 """ Node Handler for ac. This handler will be
|
|
|
1902 created by dnd3echar_handler.
|
|
|
1903 """
|
|
|
1904 def __init__(self,xml_dom,tree_node,parent):
|
|
|
1905 combat_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
1906 self.hparent = parent
|
|
|
1907 self.root = getRoot(self)
|
|
|
1908 self.root.ac = self
|
|
|
1909
|
|
|
1910 def get_spell_failure(self):
|
|
|
1911 return self.get_total('spellfailure')
|
|
|
1912
|
|
|
1913 def get_total_weight(self):
|
|
|
1914 return self.get_total('weight')
|
|
|
1915
|
|
|
1916 def get_check_pen(self):
|
|
|
1917 return self.get_total('checkpenalty')
|
|
|
1918
|
|
|
1919 def get_armor_class(self):
|
|
|
1920 ac_total = 10
|
|
|
1921
|
|
|
1922 ac_total += self.get_total('bonus')
|
|
|
1923 dex_mod = self.root.abilities.get_mod('Dex')
|
|
|
1924 max_dex = self.get_max_dex()
|
|
|
1925 if dex_mod < max_dex: ac_total += dex_mod
|
|
|
1926 else: ac_total += max_dex
|
|
|
1927 return ac_total
|
|
|
1928
|
|
|
1929 def get_max_dex(self):
|
|
|
1930 armor_list = self.xml.findall('armor')
|
|
|
1931 dex = 10
|
|
|
1932 for a in armor_list:
|
|
|
1933 temp = int(a.get("maxdex"))
|
|
|
1934 if temp < dex: dex = temp
|
|
|
1935 return dex
|
|
|
1936
|
|
|
1937 def get_total(self,attr):
|
|
|
1938 armor_list = self.xml.findall('armor')
|
|
|
1939 total = 0
|
|
|
1940 for a in armor_list: total += int(a.get(attr))
|
|
|
1941 return total
|
|
|
1942
|
|
|
1943 def get_design_panel(self,parent):
|
|
|
1944 wnd = outline_panel(parent,self,ac_panel,"Armor")
|
|
|
1945 wnd.title = "Armor"
|
|
|
1946 return wnd
|
|
|
1947
|
|
|
1948 def on_rclick( self, evt ):
|
|
|
1949 ac = self.get_armor_class()
|
|
|
1950 fac = (int(ac)-(self.root.abilities.get_mod('Dex')))
|
|
|
1951 txt = '((AC: %s Normal, %s Flatfoot))' % ( ac, fac ) #a 1.5002
|
|
36
|
1952 Parse.Post( txt, self.chat, True, True )
|
|
28
|
1953
|
|
|
1954 def tohtml(self):
|
|
|
1955 html_str = """<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 >
|
|
|
1956 <th>AC</th><th>Check Penalty</th><th >Spell Failure</th>
|
|
|
1957 <th>Max Dex</th><th>Total Weight</th></tr>"""
|
|
|
1958 html_str += "<tr ALIGN='center' >"
|
|
|
1959 html_str += "<td>"+str(self.get_armor_class())+"</td>"
|
|
|
1960 html_str += "<td>"+str(self.get_check_pen())+"</td>"
|
|
|
1961 html_str += "<td>"+str(self.get_spell_failure())+"</td>"
|
|
|
1962 html_str += "<td>"+str(self.get_max_dex())+"</td>"
|
|
|
1963 html_str += "<td>"+str(self.get_total_weight())+"</td></tr></table>"
|
|
|
1964 n_list = self.xml.getchildren()
|
|
|
1965 for n in n_list:
|
|
|
1966 html_str += """<P><table width=100% border=1 ><tr BGCOLOR=#E9E9E9 >
|
|
|
1967 <th colspan=3>Armor</th><th>Type</th><th >Bonus</th></tr>"""
|
|
|
1968 html_str += "<tr ALIGN='center' >"
|
|
|
1969 html_str += "<td colspan=3>"+n.get('name')+"</td>"
|
|
|
1970 html_str += "<td>"+n.get('type')+"</td>"
|
|
|
1971 html_str += "<td>"+n.get('bonus')+"</td></tr>"
|
|
|
1972 html_str += """<tr BGCOLOR=#E9E9E9 >"""
|
|
|
1973 html_str += "<th>Check Penalty</th><th>Spell Failure</th>"
|
|
|
1974 html_str += "<th>Max Dex</th><th>Speed</th><th>Weight</th></tr>"
|
|
|
1975 html_str += "<tr ALIGN='center'>"
|
|
|
1976 html_str += "<td>"+n.get('checkpenalty')+"</td>"
|
|
|
1977 html_str += "<td>"+n.get('spellfailure')+"</td>"
|
|
|
1978 html_str += "<td>"+n.get('maxdex')+"</td>"
|
|
|
1979 html_str += "<td>"+n.get('speed')+"</td>"
|
|
|
1980 html_str += "<td>"+n.get('weight')+"</td></tr></table>"
|
|
|
1981 return html_str
|
|
|
1982
|
|
|
1983
|
|
|
1984 class ac_panel(wx.Panel):
|
|
|
1985 def __init__(self, parent, handler):
|
|
|
1986 pname = handler.xml.set("name", 'Armor')
|
|
|
1987 self.hparent = handler
|
|
|
1988 wx.Panel.__init__(self, parent, -1)
|
|
|
1989 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1990 sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
1991 sizer.Add(self.grid, 1, wx.EXPAND)
|
|
|
1992 sizer1 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
1993 sizer1.Add(wx.Button(self, 10, "Remove Armor"), 1, wx.EXPAND)
|
|
|
1994 sizer1.Add(wx.Size(10,10))
|
|
|
1995 sizer1.Add(wx.Button(self, 20, "Add Armor"), 1, wx.EXPAND)
|
|
|
1996 sizer.Add(sizer1, 0, wx.EXPAND)
|
|
|
1997 self.sizer = sizer
|
|
|
1998 self.SetSizer(self.sizer)
|
|
|
1999 self.SetAutoLayout(True)
|
|
|
2000 self.Fit()
|
|
|
2001 self.Bind(wx.EVT_BUTTON, self.on_remove, id=10)
|
|
|
2002 self.Bind(wx.EVT_BUTTON, self.on_add, id=20)
|
|
|
2003 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
2004 self.xml = handler.xml
|
|
|
2005 n_list = handler.xml.getchildren()
|
|
|
2006 self.n_list = n_list
|
|
|
2007 col_names = ['Armor','bonus','maxdex','cp','sf','weight','speed','type']
|
|
|
2008 self.grid.CreateGrid(len(n_list),len(col_names),1)
|
|
|
2009 self.grid.SetRowLabelSize(0)
|
|
|
2010 for i in range(len(col_names)): self.grid.SetColLabelValue(i,col_names[i])
|
|
|
2011 self.atts =['name','bonus','maxdex','checkpenalty',
|
|
|
2012 'spellfailure','weight','speed','type']
|
|
|
2013 for i in range(len(n_list)): self.refresh_row(i)
|
|
|
2014 self.temp_dom = None
|
|
|
2015
|
|
|
2016
|
|
|
2017 def on_cell_change(self,evt):
|
|
|
2018 row = evt.GetRow()
|
|
|
2019 col = evt.GetCol()
|
|
|
2020 value = self.grid.GetCellValue(row,col)
|
|
|
2021 if col >= 1 and col <= 5:
|
|
|
2022 try:
|
|
|
2023 int(value)
|
|
|
2024 self.n_list[row].set(self.atts[col],value)
|
|
|
2025 except: self.grid.SetCellValue(row,col,"0")
|
|
|
2026 else: self.n_list[row].set(self.atts[col],value)
|
|
|
2027
|
|
|
2028 def refresh_row(self,i):
|
|
|
2029 n = self.n_list[i]
|
|
|
2030 for y in range(len(self.atts)): self.grid.SetCellValue(i,y,n.get(self.atts[y]))
|
|
|
2031
|
|
|
2032 def on_remove(self,evt):
|
|
|
2033 rows = self.grid.GetNumberRows()
|
|
|
2034 for i in range(rows):
|
|
|
2035 if self.grid.IsInSelection(i,0):
|
|
|
2036 self.grid.DeleteRows(i)
|
|
|
2037 self.xml.remove(self.n_list[i])
|
|
|
2038
|
|
|
2039 def on_add(self,evt):
|
|
|
2040 if not self.temp_dom:
|
|
|
2041 tree = parse(dir_struct["dnd3e"]+"dnd3earmor.xml")
|
|
|
2042 xml_dom = tree.getroot()
|
|
|
2043 self.temp_dom = xml_dom
|
|
|
2044 f_list = self.temp_dom.findall('armor')
|
|
|
2045 opts = []
|
|
|
2046 for f in f_list: opts.append(f.get('name'))
|
|
|
2047 dlg = wx.SingleChoiceDialog(self,'Choose Armor:','Armor List',opts)
|
|
|
2048 if dlg.ShowModal() == wx.ID_OK:
|
|
|
2049 i = dlg.GetSelection()
|
|
|
2050 new_node = self.xml.append(f_list[i])
|
|
|
2051 self.grid.AppendRows(1)
|
|
|
2052 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
2053 dlg.Destroy()
|
|
|
2054
|
|
|
2055 def on_size(self,event):
|
|
|
2056 s = self.GetClientSizeTuple()
|
|
|
2057 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
2058 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
2059 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
2060 cols = self.grid.GetNumberCols()
|
|
|
2061 col_w = w/(cols+2)
|
|
|
2062 self.grid.SetColSize(0,col_w*3)
|
|
|
2063 for i in range(1,cols): self.grid.SetColSize(i,col_w)
|
|
|
2064
|
|
|
2065
|
|
|
2066 class dnd3esnp(dnd3e_char_child):
|
|
|
2067 """ Node Handler for power points. This handler will be
|
|
|
2068 created by dnd3echar_handler.
|
|
|
2069 """
|
|
|
2070 def __init__(self,xml_dom,tree_node,parent):
|
|
|
2071 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
2072 dnd3e_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
2073 self.hparent = parent
|
|
|
2074 self.frame = component.get('frame')
|
|
|
2075 self.child_handlers = {}
|
|
|
2076 self.new_child_handler('spells','Spells',dnd3espells,'book')
|
|
|
2077 self.new_child_handler('divine','Divine Spells',dnd3edivine,'book')
|
|
|
2078 self.new_child_handler('powers','Powers',dnd3epowers,'book')
|
|
|
2079 self.new_child_handler('pp','Power Points',dnd3epp,'gear')
|
|
|
2080 self.myeditor = None
|
|
|
2081
|
|
|
2082 def new_child_handler(self,tag,text,handler_class,icon='gear'):
|
|
|
2083 node_list = self.xml.findall(tag)
|
|
|
2084 tree = self.tree
|
|
|
2085 i = self.tree.icons[icon]
|
|
|
2086 new_tree_node = tree.AppendItem(self.mytree_node,text,i,i)
|
|
|
2087 handler = handler_class(node_list[0],new_tree_node,self)
|
|
|
2088 tree.SetPyData(new_tree_node,handler)
|
|
|
2089 self.child_handlers[tag] = handler
|
|
|
2090
|
|
|
2091 def get_design_panel(self,parent):
|
|
|
2092 return tabbed_panel(parent,self,1)
|
|
|
2093
|
|
|
2094 def get_use_panel(self,parent):
|
|
|
2095 return tabbed_panel(parent,self,2)
|
|
|
2096
|
|
|
2097
|
|
|
2098 class snp_char_child(node_handler):
|
|
|
2099 """ Node Handler for skill. This handler will be
|
|
|
2100 created by dnd3echar_handler.
|
|
|
2101 """
|
|
|
2102 def __init__(self,xml_dom,tree_node,parent):
|
|
|
2103 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
2104 self.char_hander = parent
|
|
|
2105 self.drag = False
|
|
|
2106 self.frame = component.get('frame')
|
|
|
2107 self.myeditor = None
|
|
|
2108
|
|
|
2109 def on_drop(self,evt):
|
|
|
2110 pass
|
|
|
2111
|
|
|
2112 def on_rclick(self,evt):
|
|
|
2113 pass
|
|
|
2114
|
|
|
2115 def on_ldclick(self,evt):
|
|
|
2116 return
|
|
|
2117
|
|
|
2118 def on_html(self,evt):
|
|
|
2119 html_str = self.tohtml()
|
|
|
2120 wnd = http_html_window(self.frame.note,-1)
|
|
|
2121 wnd.title = self.xml.get('name')
|
|
|
2122 self.frame.add_panel(wnd)
|
|
|
2123 wnd.SetPage(html_str)
|
|
|
2124
|
|
|
2125 def get_design_panel(self,parent):
|
|
|
2126 pass
|
|
|
2127
|
|
|
2128 def get_use_panel(self,parent):
|
|
|
2129 return self.get_design_panel(parent)
|
|
|
2130
|
|
|
2131 def delete(self):
|
|
|
2132 pass
|
|
|
2133
|
|
|
2134
|
|
|
2135 class dnd3espells(snp_char_child):
|
|
|
2136 """ Node Handler for classes. This handler will be
|
|
|
2137 created by dnd3echar_handler.
|
|
|
2138 """
|
|
|
2139 def __init__(self,xml_dom,tree_node,parent):
|
|
|
2140 snp_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
2141 self.hparent = parent #a 1.5002 allow ability to run up tree.
|
|
|
2142 self.root = getRoot(self) #a 1.5002
|
|
|
2143 self.root.spells = self #a 1.6009
|
|
|
2144
|
|
|
2145
|
|
|
2146 node_list = self.xml.findall( 'spell' )
|
|
|
2147 self.spells = {}
|
|
|
2148 tree = self.tree
|
|
|
2149 icons = self.tree.icons
|
|
|
2150 for n in node_list:
|
|
|
2151 name = n.get('name')
|
|
|
2152 self.spells[ name ] = n
|
|
|
2153 new_tree_node = tree.AppendItem( self.mytree_node, name, icons['gear'], icons['gear'] )
|
|
|
2154 tree.SetPyData( new_tree_node, self )
|
|
|
2155
|
|
|
2156 def on_rclick( self, evt ):
|
|
|
2157 item = self.tree.GetSelection()
|
|
|
2158 name = self.tree.GetItemText( item )
|
|
|
2159 if item == self.mytree_node:
|
|
|
2160 dnd3e_char_child.on_ldclick( self, evt )
|
|
|
2161 else:
|
|
|
2162 level = self.spells[ name ].get( 'level' )
|
|
|
2163 descr = self.spells[ name ].get( 'desc' )
|
|
|
2164 use = self.spells[ name ].get( 'used' )
|
|
|
2165 memrz = self.spells[ name ].get( 'memrz' )
|
|
|
2166 use += '+1'
|
|
|
2167 charNameL=self.root.general.charName #a 1.5002
|
|
|
2168 left = eval( '%s - ( %s )' % ( memrz, use ) )
|
|
|
2169 if left < 0:
|
|
|
2170 txt = '%s Tried to cast %s but has used all of them for today,'
|
|
|
2171 txt +='"Please rest so I can cast more."' % ( charNameL, name ) #a 1.5002
|
|
36
|
2172 Parse.Post( txt, self.chat, True, False )
|
|
28
|
2173 else:
|
|
|
2174 txt = '%s casts %s ( level %s, "%s" )' % ( charNameL, name, level, descr )#a f 1.5002
|
|
36
|
2175 Parse.Post( txt, self.chat, True, False )
|
|
28
|
2176 s = ''
|
|
|
2177 if left != 1: s = 's'
|
|
|
2178 txt = '%s can cast %s %d more time%s' % ( charNameL, name, left, s ) #a 1.5002
|
|
36
|
2179 Parse.Post( txt, self.chat, False, False )
|
|
28
|
2180 self.spells[ name ].set( 'used', `eval( use )` )
|
|
|
2181
|
|
|
2182 def refresh_spells(self):
|
|
|
2183 self.spells = {}
|
|
|
2184 tree = self.tree
|
|
|
2185 icons = self.tree.icons
|
|
|
2186 tree.CollapseAndReset(self.mytree_node)
|
|
|
2187 node_list = self.xml.findall('spell')
|
|
|
2188 for n in node_list:
|
|
|
2189 name = n.get('name')
|
|
|
2190 new_tree_node = tree.AppendItem(self.mytree_node,name,icons['gear'],icons['gear'])
|
|
|
2191 tree.SetPyData(new_tree_node,self)
|
|
|
2192 self.spells[name]=n
|
|
|
2193
|
|
|
2194 def get_design_panel(self,parent):
|
|
|
2195 wnd = outline_panel(parent,self,spells_panel,"Spells")
|
|
|
2196 wnd.title = "Spells"
|
|
|
2197 return wnd
|
|
|
2198
|
|
|
2199 def tohtml(self):
|
|
|
2200 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>Arcane Spells</th></tr><tr><td><br>"
|
|
|
2201 n_list = self.xml.getchildren()
|
|
|
2202 for n in n_list: html_str += "(" + n.get('level') + ") " + n.get('name')+ ", "
|
|
|
2203 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
2204 return html_str
|
|
|
2205
|
|
|
2206 def get_char_lvl( self, attr ):
|
|
|
2207 return self.char_hander.get_char_lvl(attr)
|
|
|
2208
|
|
|
2209 class spells_panel(wx.Panel):
|
|
|
2210 def __init__(self, parent, handler):
|
|
|
2211 pname = handler.xml.set("name", 'Arcane Spells')
|
|
|
2212 self.hparent = handler #a 1.5002 allow ability to run up tree.
|
|
|
2213 wx.Panel.__init__(self, parent, -1)
|
|
|
2214 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
2215 self.handler = handler
|
|
|
2216 sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
2217 sizer.Add(self.grid, 1, wx.EXPAND)
|
|
|
2218 sizer1 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
2219 sizer1.Add(wx.Button(self, 10, "Remove Spell"), 1, wx.EXPAND)
|
|
|
2220 sizer1.Add(wx.Size(10,10))
|
|
|
2221 sizer1.Add(wx.Button(self, 20, "Add Spell"), 1, wx.EXPAND)
|
|
|
2222 sizer1.Add(wx.Size(10,10))
|
|
|
2223 sizer1.Add(wx.Button(self, 30, "Refresh Spells"), 1, wx.EXPAND)
|
|
|
2224 sizer.Add(sizer1, 0, wx.EXPAND)
|
|
|
2225 self.sizer = sizer
|
|
|
2226 self.SetSizer(self.sizer)
|
|
|
2227 self.SetAutoLayout(True)
|
|
|
2228 self.Fit()
|
|
|
2229 self.Bind(wx.EVT_BUTTON, self.on_remove, id=10)
|
|
|
2230 self.Bind(wx.EVT_BUTTON, self.on_add, id=20)
|
|
|
2231 self.Bind(wx.EVT_BUTTON, self.on_refresh_spells, id=30)
|
|
|
2232 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
2233 n_list = handler.xml.getchildren()
|
|
|
2234 self.n_list = n_list
|
|
|
2235 self.xml = handler.xml
|
|
|
2236 self.grid.CreateGrid(len(n_list),4,1)
|
|
|
2237 self.grid.SetRowLabelSize(0)
|
|
|
2238 self.grid.SetColLabelValue(0,"No.")
|
|
|
2239 self.grid.SetColLabelValue(1,"Lvl")
|
|
|
2240 self.grid.SetColLabelValue(2,"Spell")
|
|
|
2241 self.grid.SetColLabelValue(3,"Desc")
|
|
|
2242 for i in range(len(n_list)): self.refresh_row(i)
|
|
|
2243 self.temp_dom = None
|
|
|
2244
|
|
|
2245 def on_cell_change(self,evt):
|
|
|
2246 row = evt.GetRow()
|
|
|
2247 col = evt.GetCol()
|
|
|
2248 value = self.grid.GetCellValue(row,col)
|
|
|
2249 if col == 0: self.n_list[row].set('memrz',value)
|
|
|
2250
|
|
|
2251 def refresh_row(self,i):
|
|
|
2252 spell = self.n_list[i]
|
|
|
2253 memrz = spell.get('memrz')
|
|
|
2254 name = spell.get('name')
|
|
|
2255 type = spell.get('desc')
|
|
|
2256 level = spell.get('level')
|
|
|
2257 self.grid.SetCellValue(i,0,memrz)
|
|
|
2258 self.grid.SetCellValue(i,2,name)
|
|
|
2259 self.grid.SetReadOnly(i,2)
|
|
|
2260 self.grid.SetCellValue(i,3,type)
|
|
36
|
2261 self.grid.SetReadOnly(i,3)
|
|
|
2262 self.grid.SetCellValue(i,1,level)
|
|
28
|
2263 self.grid.SetReadOnly(i,1)
|
|
|
2264
|
|
|
2265 def on_remove(self,evt):
|
|
|
2266 rows = self.grid.GetNumberRows()
|
|
|
2267 for i in range(rows):
|
|
|
2268 if self.grid.IsInSelection(i,0):
|
|
|
2269 self.grid.DeleteRows(i)
|
|
|
2270 self.xml.remove(self.n_list[i])
|
|
|
2271
|
|
|
2272 def on_add(self,evt):
|
|
|
2273 if not self.temp_dom:
|
|
|
2274 tree = parse(dir_struct["dnd3e"]+"dnd3espells.xml")
|
|
|
2275 xml_dom = tree.getroot()
|
|
|
2276 self.temp_dom = xml_dom
|
|
|
2277 f_list = self.temp_dom.findall('spell')
|
|
|
2278 opts = []
|
|
|
2279 #lvl = int(dnd3e_char_child.get_char_lvl('level'))
|
|
|
2280 #castlvl = eval('%s/2' % (lvl))
|
|
|
2281 for f in f_list:
|
|
|
2282 spelllvl = f.get('level')
|
|
|
2283 opts.append("(" + f.get('level') + ")" + f.get('name'))
|
|
|
2284 dlg = wx.SingleChoiceDialog(self,'Choose Spell','Spells',opts)
|
|
|
2285 if dlg.ShowModal() == wx.ID_OK:
|
|
|
2286 i = dlg.GetSelection()
|
|
|
2287 new_node = self.xml.append(f_list[i])
|
|
|
2288 self.grid.AppendRows(1)
|
|
|
2289 self.n_list = self.xml.findall('spell')
|
|
|
2290 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
2291 self.handler.refresh_spells()
|
|
|
2292 dlg.Destroy()
|
|
|
2293
|
|
|
2294 def on_refresh_spells( self, evt ):
|
|
|
2295 f_list = self.xml.findall('spell')
|
|
|
2296 for spell in f_list: spell.set( 'used', '0' )
|
|
|
2297
|
|
|
2298 def on_size(self,event):
|
|
|
2299 s = self.GetClientSizeTuple()
|
|
|
2300 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
2301 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
2302 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
2303 cols = self.grid.GetNumberCols()
|
|
|
2304 col_w = w/(cols)
|
|
|
2305 for i in range(0,cols): self.grid.SetColSize(i,col_w)
|
|
|
2306 self.grid.SetColSize(0,w * 0.10)
|
|
|
2307 self.grid.SetColSize(1,w * 0.10)
|
|
|
2308 self.grid.SetColSize(2,w * 0.30)
|
|
|
2309 self.grid.SetColSize(3,w * 0.50)
|
|
|
2310
|
|
|
2311 def refresh_data(self):
|
|
|
2312 for i in range(len(self.n_list)): self.refresh_row(i)
|
|
|
2313
|
|
|
2314 class dnd3edivine(snp_char_child):
|
|
|
2315 """ Node Handler for classes. This handler will be
|
|
|
2316 created by dnd3echar_handler.
|
|
|
2317 """
|
|
|
2318 def __init__(self,xml_dom,tree_node,parent):
|
|
|
2319 snp_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
2320 self.hparent = parent #a 1.5002 allow ability to run up tree.
|
|
|
2321 self.root = getRoot(self) #a 1.5002
|
|
|
2322 self.root.divine = self #a 1.6009
|
|
|
2323 node_list = self.xml.findall( 'gift' )
|
|
|
2324 self.spells = {}
|
|
|
2325 tree = self.tree
|
|
|
2326 icons = self.tree.icons
|
|
|
2327 for n in node_list:
|
|
|
2328 name = n.get('name')
|
|
|
2329 self.spells[ name ] = n
|
|
|
2330 new_tree_node = tree.AppendItem( self.mytree_node, name, icons['flask'], icons['flask'] )
|
|
|
2331 tree.SetPyData( new_tree_node, self )
|
|
|
2332
|
|
|
2333 def on_rclick( self, evt ):
|
|
|
2334 charNameL=self.root.general.charName #a f 1.5002
|
|
|
2335 item = self.tree.GetSelection()
|
|
|
2336 name = self.tree.GetItemText( item )
|
|
|
2337 if item == self.mytree_node:
|
|
|
2338 dnd3e_char_child.on_ldclick( self, evt )
|
|
|
2339 else:
|
|
|
2340 level = self.spells[ name ].get( 'level' )
|
|
|
2341 descr = self.spells[ name ].get( 'desc' )
|
|
|
2342 use = self.spells[ name ].get( 'used' )
|
|
|
2343 memrz = self.spells[ name ].get( 'memrz' )
|
|
|
2344 use += '+1'
|
|
|
2345 left = eval( '%s - ( %s )' % ( memrz, use ) )
|
|
|
2346 if left < 0:
|
|
|
2347 txt = '%s Tried to cast %s but has used all of them for today,' #m 1.5002 break in 2.
|
|
|
2348 txt += "Please rest so I can cast more."' % ( charNameL, name )' #a 1.5002
|
|
36
|
2349 Parse.Post( txt, self.chat, True, False )
|
|
28
|
2350 else:
|
|
|
2351 txt = '%s casts %s ( level %s, "%s" )' % ( charNameL, name, level, descr ) #a 5002
|
|
36
|
2352 Parse.Post( txt, self.chat, True, False )
|
|
28
|
2353 s = ''
|
|
|
2354 if left != 1: s = 's'
|
|
|
2355 txt = '%s can cast %s %d more time%s' % ( charNameL, name, left, s ) #a 1.5002
|
|
36
|
2356 Parse.Post( txt, self.chat, False, False )
|
|
28
|
2357 self.spells[ name ].set( 'used', `eval( use )` )
|
|
|
2358
|
|
|
2359 def refresh_spells(self):
|
|
|
2360 self.spells = {}
|
|
|
2361 tree = self.tree
|
|
|
2362 icons = self.tree.icons
|
|
|
2363 tree.CollapseAndReset(self.mytree_node)
|
|
|
2364 node_list = self.xml.findall('gift')
|
|
|
2365 for n in node_list:
|
|
|
2366 name = n.get('name')
|
|
|
2367 new_tree_node = tree.AppendItem(self.mytree_node,name,icons['flask'],icons['flask'])
|
|
|
2368 tree.SetPyData(new_tree_node,self)
|
|
|
2369 self.spells[name]=n
|
|
|
2370
|
|
|
2371 def get_design_panel(self,parent):
|
|
|
2372 wnd = outline_panel(parent,self,divine_panel,"Spells")
|
|
|
2373 wnd.title = "Spells"
|
|
|
2374 return wnd
|
|
|
2375
|
|
|
2376 def tohtml(self):
|
|
|
2377 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>Divine Spells</th></tr><tr><td><br>"
|
|
|
2378 n_list = self.xml.getchildren()
|
|
|
2379 for n in n_list: html_str += "(" + n.get('level') + ") " + n.get('name')+ ", "
|
|
|
2380 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
2381 return html_str
|
|
|
2382
|
|
|
2383 def get_char_lvl( self, attr ):
|
|
|
2384 return self.char_hander.get_char_lvl(attr)
|
|
|
2385
|
|
|
2386 class divine_panel(wx.Panel):
|
|
|
2387 def __init__(self, parent, handler):
|
|
|
2388 pname = handler.xml.set("name", 'Divine Spells')
|
|
|
2389 self.hparent = handler
|
|
|
2390 wx.Panel.__init__(self, parent, -1)
|
|
|
2391 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
2392 self.handler = handler
|
|
|
2393 sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
2394 sizer.Add(self.grid, 1, wx.EXPAND)
|
|
|
2395 sizer1 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
2396 sizer1.Add(wx.Button(self, 10, "Remove Spell"), 1, wx.EXPAND)
|
|
|
2397 sizer1.Add(wx.Size(10,10))
|
|
|
2398 sizer1.Add(wx.Button(self, 20, "Add Spell"), 1, wx.EXPAND)
|
|
|
2399 sizer1.Add(wx.Size(10,10))
|
|
|
2400 sizer1.Add(wx.Button(self, 30, "Refresh Spells"), 1, wx.EXPAND)
|
|
|
2401 sizer.Add(sizer1, 0, wx.EXPAND)
|
|
|
2402 self.sizer = sizer
|
|
|
2403 self.SetSizer(self.sizer)
|
|
|
2404 self.SetAutoLayout(True)
|
|
|
2405 self.Fit()
|
|
36
|
2406
|
|
|
2407 self.Bind(wx.EVT_BUTTON, self.on_remove, id=10)
|
|
28
|
2408 self.Bind(wx.EVT_BUTTON, self.on_add, id=20)
|
|
|
2409 self.Bind(wx.EVT_BUTTON, self.on_refresh_spells, id=30)
|
|
|
2410 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
2411
|
|
|
2412 n_list = handler.xml.getchildren()
|
|
|
2413 self.n_list = n_list
|
|
|
2414 self.xml = handler.xml
|
|
|
2415 self.grid.CreateGrid(len(n_list),4,1)
|
|
|
2416 self.grid.SetRowLabelSize(0)
|
|
|
2417 self.grid.SetColLabelValue(0,"No.")
|
|
|
2418 self.grid.SetColLabelValue(1,"Lvl")
|
|
|
2419 self.grid.SetColLabelValue(2,"Spell")
|
|
|
2420 self.grid.SetColLabelValue(3,"Desc")
|
|
|
2421 for i in range(len(n_list)): self.refresh_row(i)
|
|
|
2422 self.temp_dom = None
|
|
|
2423
|
|
|
2424 def on_cell_change(self,evt):
|
|
|
2425 row = evt.GetRow()
|
|
|
2426 col = evt.GetCol()
|
|
|
2427 value = self.grid.GetCellValue(row,col)
|
|
|
2428 if col == 0: self.n_list[row].set('memrz',value)
|
|
|
2429
|
|
|
2430 def refresh_row(self,i):
|
|
|
2431 spell = self.n_list[i]
|
|
|
2432 memrz = spell.get('memrz')
|
|
|
2433 name = spell.get('name')
|
|
|
2434 type = spell.get('desc')
|
|
|
2435 level = spell.get('level')
|
|
|
2436 self.grid.SetCellValue(i,0,memrz)
|
|
|
2437 self.grid.SetCellValue(i,2,name)
|
|
|
2438 self.grid.SetReadOnly(i,2)
|
|
|
2439 self.grid.SetCellValue(i,3,type)
|
|
|
2440 self.grid.SetReadOnly(i,3)
|
|
|
2441 self.grid.SetCellValue(i,1,level)
|
|
|
2442 self.grid.SetReadOnly(i,1)
|
|
|
2443
|
|
|
2444 def on_remove(self,evt):
|
|
|
2445 rows = self.grid.GetNumberRows()
|
|
|
2446 for i in range(rows):
|
|
|
2447 if self.grid.IsInSelection(i,0):
|
|
|
2448 self.grid.DeleteRows(i)
|
|
|
2449 self.xml.remove(self.n_list[i])
|
|
|
2450
|
|
|
2451 def on_add(self,evt):
|
|
|
2452 if not self.temp_dom:
|
|
|
2453 tree = parse(dir_struct["dnd3e"]+"dnd3edivine.xml")
|
|
|
2454 xml_dom = tree.getroot()
|
|
|
2455 self.temp_dom = xml_dom
|
|
|
2456 f_list = self.temp_dom.findall('gift')
|
|
|
2457 opts = []
|
|
|
2458 for f in f_list:
|
|
|
2459 spelllvl = f.get('level')
|
|
|
2460 opts.append("(" + f.get('level') + ")" + f.get('name'))
|
|
|
2461 dlg = wx.SingleChoiceDialog(self,'Choose Spell','Spells',opts)
|
|
|
2462 if dlg.ShowModal() == wx.ID_OK:
|
|
|
2463 i = dlg.GetSelection()
|
|
|
2464 new_node = self.xml.append(f_list[i])
|
|
|
2465 self.grid.AppendRows(1)
|
|
|
2466 self.n_list = self.xml.findall('gift')
|
|
|
2467 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
2468 self.handler.refresh_spells()
|
|
|
2469 dlg.Destroy()
|
|
|
2470
|
|
|
2471 def on_refresh_spells( self, evt ):
|
|
|
2472 f_list = self.xml.findall('gift')
|
|
|
2473 for spell in f_list: spell.set( 'used', '0' )
|
|
|
2474
|
|
|
2475 def on_size(self,event):
|
|
|
2476 s = self.GetClientSizeTuple()
|
|
|
2477 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
2478 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
2479 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
2480 cols = self.grid.GetNumberCols()
|
|
|
2481 col_w = w/(cols)
|
|
|
2482 for i in range(0,cols): self.grid.SetColSize(i,col_w)
|
|
|
2483 self.grid.SetColSize(0,w * 0.10)
|
|
|
2484 self.grid.SetColSize(1,w * 0.10)
|
|
|
2485 self.grid.SetColSize(2,w * 0.30)
|
|
|
2486 self.grid.SetColSize(3,w * 0.50)
|
|
|
2487
|
|
|
2488 def refresh_data(self):
|
|
|
2489 for i in range(len(self.n_list)): self.refresh_row(i)
|
|
|
2490
|
|
|
2491
|
|
|
2492 class dnd3epowers(snp_char_child):
|
|
|
2493 """ Node Handler for classes. This handler will be
|
|
|
2494 created by dnd3echar_handler.
|
|
|
2495 """
|
|
|
2496 def __init__(self,xml_dom,tree_node,parent):
|
|
|
2497 snp_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
2498 self.hparent = parent #a 1.5002 allow ability to run up tree.
|
|
|
2499 self.root = getRoot(self) #a 1.5002
|
|
|
2500 self.root.powers = self #a 1.6009
|
|
|
2501
|
|
|
2502 node_list = self.xml.findall( 'power' )
|
|
|
2503 self.powers = {}
|
|
|
2504 tree = self.tree
|
|
|
2505 icons = self.tree.icons
|
|
|
2506 for n in node_list:
|
|
|
2507 name = n.get('name')
|
|
|
2508 self.powers[ name ] = n
|
|
|
2509 new_tree_node = tree.AppendItem( self.mytree_node, name,
|
|
|
2510 icons['gear'], icons['gear'] )
|
|
|
2511 tree.SetPyData( new_tree_node, self )
|
|
|
2512
|
|
|
2513 def on_rclick( self, evt ):
|
|
|
2514 charNameL = self.root.general.charName #a f 1.5002
|
|
|
2515
|
|
|
2516 item = self.tree.GetSelection()
|
|
|
2517 name = self.tree.GetItemText( item )
|
|
|
2518 charNameL = self.root.general.charName #a 1.5002
|
|
|
2519 if item == self.mytree_node:
|
|
|
2520 dnd3e_char_child.on_ldclick( self, evt )
|
|
|
2521 else:
|
|
|
2522 level = int(self.powers[ name ].get( 'level' ))
|
|
|
2523 descr = self.powers[ name ].get( 'desc' )
|
|
|
2524 #use can be removed -mgt
|
|
|
2525 #use = self.powers[ name ].get( 'used' )
|
|
|
2526 points = self.powers[ name ].get( 'point' )
|
|
|
2527 #cpp and fre are strings without the eval -mgt
|
|
|
2528 cpp = eval(self.root.pp.get_char_pp('current1')) #a 1.5002
|
|
|
2529 fre = eval(self.root.pp.get_char_pp('free')) #a 1.5002
|
|
|
2530 if level == 0 and fre > 0:
|
|
|
2531 left = eval('%s - ( %s )' % ( fre, points ))
|
|
|
2532 numcast = eval('%s / %s' % (left, points))
|
|
|
2533 if left < 0:
|
|
|
2534 #In theory you should never see this -mgt
|
|
|
2535 txt = ('%s doesnt have enough PowerPoints to use %s'
|
|
|
2536 % ( charNameL, name )) #a 1.5002
|
|
36
|
2537 Parse.Post( txt, self.chat, True, False )
|
|
28
|
2538 else:
|
|
|
2539 txt = ('%s uses %s as a Free Talent ( level %s, "%s" )'
|
|
|
2540 % ( charNameL, name, level, descr )) #a 1.5002
|
|
36
|
2541 Parse.Post( txt, self.chat, True, False )
|
|
28
|
2542 s = ''
|
|
|
2543 if left != 1: s = 's'
|
|
|
2544 txt = '%s has %d Free Talent%s left' % ( charNameL, numcast, s ) #a 1.5002
|
|
36
|
2545 Parse.Post( txt, self.chat, False, False )
|
|
28
|
2546 self.root.pp.set_char_pp('free',left) #a 1.5002
|
|
|
2547 else:
|
|
|
2548 left = eval('%s - ( %s )' % ( cpp, points ))
|
|
|
2549 #numcast = eval('%s / %s' % (left, points))
|
|
|
2550 if left < 0:
|
|
|
2551 txt = '%s doesnt have enough PowerPoints to use %s' % ( charNameL, name ) #m 1.5002
|
|
36
|
2552 Parse.Post( txt, self.chat, True, False )
|
|
28
|
2553 else:
|
|
|
2554 txt = '%s uses %s ( level %s, "%s" )' % ( charNameL, name, level, descr ) #m 1.5002
|
|
36
|
2555 Parse.Post( txt, self.chat, True, False )
|
|
28
|
2556 s = ''
|
|
|
2557 if left != 1:
|
|
|
2558 s = 's'
|
|
|
2559 #numcast is meaningless here -mgt
|
|
|
2560 #txt = '%s can use %s %d more time%s' % ( charNameL, name, numcast, s ) #m 1.5002
|
|
|
2561 #txt += ' - And has %d more PowerpointsP left' % (left)
|
|
|
2562 txt = '%s has %d more Powerpoint%s' % ( charNameL, left, s ) #m 1.5002
|
|
36
|
2563 Parse.Post( txt, self.chat, False, False )
|
|
28
|
2564 self.root.pp.set_char_pp('current1',left) #a 1.5002
|
|
|
2565
|
|
|
2566 def refresh_powers(self):
|
|
|
2567 self.powers = {}
|
|
|
2568 tree = self.tree
|
|
|
2569 icons = self.tree.icons
|
|
|
2570 tree.CollapseAndReset(self.mytree_node)
|
|
|
2571 node_list = self.xml.findall('power')
|
|
|
2572 for n in node_list:
|
|
|
2573 name = n.get('name')
|
|
|
2574 new_tree_node = tree.AppendItem(self.mytree_node,name,icons['gear'],icons['gear'])
|
|
|
2575 tree.SetPyData(new_tree_node,self)
|
|
|
2576 self.powers[name]=n
|
|
|
2577
|
|
|
2578 def get_design_panel(self,parent):
|
|
|
2579 wnd = outline_panel(parent,self,power_panel,"Powers")
|
|
|
2580 wnd.title = "Powers"
|
|
|
2581 return wnd
|
|
|
2582
|
|
|
2583 def tohtml(self):
|
|
|
2584 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>Powers</th></tr><tr><td><br>"
|
|
|
2585 n_list = self.xml.getchildren()
|
|
|
2586 for n in n_list:
|
|
|
2587 html_str += "(" + n.get('level') + ") " + n.get('name')+ ", "
|
|
|
2588 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
2589 return html_str
|
|
|
2590
|
|
|
2591
|
|
|
2592 class power_panel(wx.Panel):
|
|
|
2593 def __init__(self, parent, handler):
|
|
|
2594 #m 1.5015 corrected typo, was Pionic.
|
|
|
2595 pname = handler.xml.set("name", 'Psionic Powers')
|
|
|
2596 self.hparent = handler
|
|
|
2597 self.root = getRoot(self) #a (debug) 1.5002,1.5014
|
|
|
2598
|
|
|
2599 wx.Panel.__init__(self, parent, -1)
|
|
|
2600 self.grid = wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
2601 self.handler = handler
|
|
|
2602 sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
2603 sizer.Add(self.grid, 1, wx.EXPAND)
|
|
|
2604
|
|
|
2605 sizer1 = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
2606 sizer1.Add(wx.Button(self, 10, "Remove Power"), 1, wx.EXPAND)
|
|
|
2607 sizer1.Add(wx.Size(10,10))
|
|
|
2608 sizer1.Add(wx.Button(self, 20, "Add Power"), 1, wx.EXPAND)
|
|
|
2609 sizer1.Add(wx.Size(10,10))
|
|
|
2610 sizer1.Add(wx.Button(self, 30, "Refresh Power"), 1, wx.EXPAND)
|
|
|
2611
|
|
|
2612 sizer.Add(sizer1, 0, wx.EXPAND)
|
|
|
2613 self.sizer = sizer
|
|
|
2614 self.SetSizer(self.sizer)
|
|
|
2615 self.SetAutoLayout(True)
|
|
|
2616 self.Fit()
|
|
|
2617 #self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
2618
|
|
|
2619 self.Bind(wx.EVT_BUTTON, self.on_remove, id=10)
|
|
|
2620 self.Bind(wx.EVT_BUTTON, self.on_add, id=20)
|
|
|
2621 self.Bind(wx.EVT_BUTTON, self.on_refresh_powers, id=30)
|
|
|
2622 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
2623 n_list = handler.xml.getchildren()
|
|
|
2624 self.n_list = n_list
|
|
|
2625 self.xml = handler.xml
|
|
|
2626 self.grid.CreateGrid(len(n_list),5,1)
|
|
|
2627 self.grid.SetRowLabelSize(0)
|
|
|
2628 self.grid.SetColLabelValue(0,"PP")
|
|
|
2629 self.grid.SetColLabelValue(1,"Lvl")
|
|
|
2630 self.grid.SetColLabelValue(2,"Power")
|
|
|
2631 self.grid.SetColLabelValue(3,"Desc")
|
|
|
2632 self.grid.SetColLabelValue(4,"Type")
|
|
|
2633 for i in range(len(n_list)): self.refresh_row(i)
|
|
|
2634 self.refresh_data()
|
|
|
2635 self.temp_dom = None
|
|
|
2636
|
|
|
2637 def on_cell_change(self,evt):
|
|
|
2638 row = evt.GetRow()
|
|
|
2639 col = evt.GetCol()
|
|
|
2640 value = self.grid.GetCellValue(row,col)
|
|
|
2641
|
|
|
2642 def refresh_row(self,i):
|
|
|
2643 power = self.n_list[i]
|
|
|
2644 point = power.get('point')
|
|
|
2645 name = power.get('name')
|
|
|
2646 type = power.get('desc')
|
|
|
2647 test = power.get('test')
|
|
|
2648 level = power.get('level')
|
|
|
2649 self.grid.SetCellValue(i,0,point)
|
|
|
2650 self.grid.SetReadOnly(i,0)
|
|
|
2651 self.grid.SetCellValue(i,1,level)
|
|
|
2652 self.grid.SetReadOnly(i,1)
|
|
|
2653 self.grid.SetCellValue(i,2,name)
|
|
|
2654 self.grid.SetReadOnly(i,2)
|
|
|
2655 self.grid.SetCellValue(i,3,type)
|
|
|
2656 self.grid.SetReadOnly(i,3)
|
|
|
2657 self.grid.SetCellValue(i,4,test)
|
|
|
2658 self.grid.SetReadOnly(i,4)
|
|
|
2659
|
|
|
2660 def on_remove(self,evt):
|
|
|
2661 rows = self.grid.GetNumberRows()
|
|
|
2662 for i in range(rows):
|
|
|
2663 if self.grid.IsInSelection(i,0):
|
|
|
2664 self.grid.DeleteRows(i)
|
|
|
2665 self.xml.remove(self.n_list[i])
|
|
|
2666
|
|
|
2667 def on_add(self,evt):
|
|
|
2668 if not self.temp_dom:
|
|
|
2669 tree = parse(dir_struct["dnd3e"]+"dnd3epowers.xml")
|
|
|
2670 xml_dom = tree.getroot()
|
|
|
2671 self.temp_dom = xml_dom
|
|
|
2672 f_list = self.temp_dom.findall('power')
|
|
|
2673 opts = []
|
|
|
2674 for f in f_list:
|
|
|
2675 spelllvl = f.get('level')
|
|
|
2676 opts.append("(" + f.get('level') + ") - " +
|
|
|
2677 f.get('name') + " - " + f.get('test'))
|
|
|
2678 dlg = wx.SingleChoiceDialog(self,'Choose Power','Powers',opts)
|
|
|
2679 if dlg.ShowModal() == wx.ID_OK:
|
|
|
2680 i = dlg.GetSelection()
|
|
|
2681 new_node = self.xml.append(f_list[i])
|
|
|
2682 self.grid.AppendRows(1)
|
|
|
2683 self.n_list = self.xml.findall('power')
|
|
|
2684 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
2685 self.handler.refresh_powers()
|
|
|
2686 dlg.Destroy()
|
|
|
2687
|
|
|
2688 def on_remove(self,evt):
|
|
|
2689 rows = self.grid.GetNumberRows()
|
|
|
2690 for i in range(rows):
|
|
|
2691 if self.grid.IsInSelection(i,0):
|
|
|
2692 self.grid.DeleteRows(i)
|
|
|
2693 self.xml.remove(self.n_list[i])
|
|
|
2694 self.n_list = self.xml.findall('weapon')
|
|
|
2695 self.handler.refresh_powers()
|
|
|
2696
|
|
|
2697 def on_refresh_powers( self, evt ):
|
|
|
2698 self.root.pp.set_char_pp('current1',self.root.pp.get_char_pp('max1'))
|
|
|
2699 self.root.pp.set_char_pp('free',self.root.pp.get_char_pp('maxfree'))
|
|
|
2700
|
|
|
2701 def on_size(self,event):
|
|
|
2702 s = self.GetClientSizeTuple()
|
|
|
2703 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
2704 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
2705 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
2706 cols = self.grid.GetNumberCols()
|
|
|
2707 col_w = w/(cols)
|
|
|
2708 for i in range(0,cols): self.grid.SetColSize(i,col_w)
|
|
|
2709 self.grid.SetColSize(0,w * 0.05)
|
|
|
2710 self.grid.SetColSize(1,w * 0.05)
|
|
|
2711 self.grid.SetColSize(2,w * 0.30)
|
|
|
2712 self.grid.SetColSize(3,w * 0.30)
|
|
|
2713 self.grid.SetColSize(4,w * 0.30)
|
|
|
2714
|
|
|
2715 def refresh_data(self):
|
|
|
2716 for i in range(len(self.n_list)): self.refresh_row(i)
|
|
|
2717
|
|
|
2718 class dnd3epp(snp_char_child):
|
|
|
2719 """ Node Handler for power points. This handler will be
|
|
|
2720 created by dnd3echar_handler.
|
|
|
2721 """
|
|
|
2722 def __init__(self,xml_dom,tree_node,parent):
|
|
|
2723 snp_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
2724 self.hparent = parent #a 1.5002 allow ability to run up tree.
|
|
|
2725 self.root = getRoot(self)
|
|
|
2726 self.root.pp = self
|
|
|
2727 self.ppPanel=None
|
|
|
2728
|
|
|
2729 def get_design_panel(self,parent):
|
|
|
2730 wnd = outline_panel(parent,self,pp_panel,"Power Points")
|
|
|
2731 wnd.title = "Power Points"
|
|
|
2732 return wnd
|
|
|
2733
|
|
|
2734
|
|
|
2735 def tohtml(self):
|
|
|
2736 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 >"
|
|
|
2737 html_str += "<th colspan=7>Power Points</th>" #a 1.6010
|
|
|
2738 html_str += "</tr><tr>"
|
|
|
2739 html_str += "<th colspan=2>Max:</th>"
|
|
|
2740 html_str += "<td>"+self.xml.get('max1')+"</td>"
|
|
|
2741 html_str += "<th colspan=3>Max Talents/day:</th>"
|
|
|
2742 html_str += "<td>"+self.xml.get('maxfree')+"</td>"
|
|
|
2743 html_str += "</tr><tr>"
|
|
|
2744 html_str += "<th colspan=2>Current:</th>"
|
|
|
2745 html_str += "<td>"+self.xml.get('current1')+"</td>"
|
|
|
2746 html_str += "<th colspan=3>Current Talents/day:</th>"
|
|
|
2747 html_str += "<td>"+self.xml.get('free')+"</td>"
|
|
|
2748 html_str += "</tr></table>"
|
|
|
2749 return html_str
|
|
|
2750
|
|
|
2751 def get_char_pp( self, attr ):
|
|
|
2752 pp = self.xml.get(attr)
|
|
|
2753 return pp
|
|
|
2754
|
|
|
2755 def set_char_pp( self, attr, evl ):
|
|
|
2756 qSub = str(evl) #a 1.5014 must force it to be a string for next call.
|
|
|
2757 self.xml.set(attr, qSub)
|
|
|
2758
|
|
|
2759 class pp_panel(wx.Panel):
|
|
|
2760 def __init__(self, parent, handler):
|
|
|
2761 wx.Panel.__init__(self, parent, -1)
|
|
|
2762 self.hparent = handler #a 1.5002 allow ability to run up tree.
|
|
|
2763 self.hparent.ppPanel=self #a 1.5xx
|
|
|
2764
|
|
|
2765 pname = handler.xml.set("name", 'PowerPoints')
|
|
|
2766 self.sizer = wx.FlexGridSizer(2, 4, 2, 2) # rows, cols, hgap, vgap
|
|
|
2767 self.xml = handler.xml
|
|
|
2768
|
|
|
2769 self.static1= wx.StaticText(self, -1, "PP Current:") #a 1.5015
|
|
|
2770 self.dyn1= wx.TextCtrl(self, PP_CUR,
|
|
|
2771 self.xml.get('current1')) #a 1.5015
|
|
|
2772 self.dyn3= wx.TextCtrl(self, PP_FRE,
|
|
|
2773 self.xml.get('free')) #a 1.5015
|
|
|
2774 self.sizer.AddMany([ (self.static1, 0, wx.ALIGN_CENTER_VERTICAL),
|
|
|
2775 (self.dyn1, 0, wx.EXPAND),
|
|
|
2776 (wx.StaticText(self, -1, "PP Max:"), 0, wx.ALIGN_CENTER_VERTICAL),
|
|
|
2777 (wx.TextCtrl(self, PP_MAX,
|
|
|
2778 self.xml.get('max1')), 0, wx.EXPAND),
|
|
|
2779 (wx.StaticText(self, -1, "Current Free Talants per day:"),
|
|
|
2780 0, wx.ALIGN_CENTER_VERTICAL),
|
|
|
2781 (self.dyn3, 0, wx.EXPAND), #a 1.5015
|
|
|
2782 (wx.StaticText(self, -1, "Max Free Talants per day:"),
|
|
|
2783 0, wx.ALIGN_CENTER_VERTICAL),
|
|
|
2784 (wx.TextCtrl(self, PP_MFRE,
|
|
|
2785 self.xml.get('maxfree')), 0, wx.EXPAND),
|
|
|
2786 ])
|
|
|
2787
|
|
|
2788 self.sizer.AddGrowableCol(1)
|
|
|
2789 self.SetSizer(self.sizer)
|
|
|
2790 self.SetAutoLayout(True)
|
|
|
2791 self.Fit()
|
|
|
2792 self.Bind(wx.EVT_TEXT, self.on_text, id=PP_MAX)
|
|
|
2793 self.Bind(wx.EVT_TEXT, self.on_text, id=PP_CUR)
|
|
|
2794 self.Bind(wx.EVT_TEXT, self.on_text, id=PP_FRE)
|
|
|
2795 self.Bind(wx.EVT_TEXT, self.on_text, id=PP_MFRE)
|
|
|
2796
|
|
|
2797 def on_text(self,evt):
|
|
|
2798 id = evt.GetId()
|
|
|
2799 if id == PP_CUR: self.xml.set('current1',evt.GetString())
|
|
|
2800 elif id == PP_MAX: self.xml.set('max1',evt.GetString())
|
|
|
2801 elif id == PP_FRE: self.xml.set('free',evt.GetString())
|
|
|
2802 elif id == PP_MFRE: self.xml.set('maxfree',evt.GetString())
|
|
|
2803
|
|
|
2804 def on_size(self,evt):
|
|
|
2805 s = self.GetClientSizeTuple()
|
|
|
2806 self.sizer.SetDimension(0,0,s[0],s[1])
|
|
|
2807
|
|
|
2808 #a 5.015 this whole function.
|
|
|
2809 def on_refresh(self,attr,value):
|
|
|
2810 if attr == 'current1': self.dyn1.SetValue(value)
|
|
|
2811 else: self.dyn3.SetValue(value)
|
