|
17
|
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: StarWarsd20.py
|
|
|
21 # Author: Chris Davis; Mark Twombley
|
|
|
22 # Maintainer: Mark Twombley
|
|
|
23 # Version:
|
|
28
|
24 # $Id: StarWarsd20.py,v Traipse 'Ornery-Orc' prof.ebral Exp $
|
|
17
|
25 #
|
|
|
26 # Description: The file contains code for the StarWarsd20 nodehanlers
|
|
|
27 #
|
|
|
28
|
|
28
|
29 __version__ = "$Id: StarWarsd20.py,v Traipse 'Ornery-Orc' prof.ebral Exp $"
|
|
17
|
30
|
|
|
31 from core import *
|
|
28
|
32 from containers import *
|
|
|
33 from orpg.tools.orpg_log import debug
|
|
|
34 from xml.etree.ElementTree import parse
|
|
17
|
35
|
|
|
36 SWD20_EXPORT = wx.NewId()
|
|
|
37 ############################
|
|
|
38 ## StarWarsd20 character node handler
|
|
|
39 ############################
|
|
|
40 ##The whole look and easy of use redone by Digitalxero
|
|
|
41 class container_handler(node_handler):
|
|
|
42 """ should not be used! only a base class!
|
|
|
43 <nodehandler name='?' module='core' class='container_handler' />
|
|
|
44 """
|
|
|
45 def __init__(self,xml_dom,tree_node):
|
|
|
46 node_handler.__init__(self,xml_dom,tree_node)
|
|
|
47 self.load_children()
|
|
|
48
|
|
|
49 def load_children(self):
|
|
28
|
50 children = self.xml.getchildren()
|
|
17
|
51 for c in children:
|
|
|
52 self.tree.load_xml(c,self.mytree_node)
|
|
|
53
|
|
|
54 def on_drop(self,evt):
|
|
|
55 drag_obj = self.tree.drag_obj
|
|
|
56 #if self.is_my_child(self.mytree_node,drag_obj.mytree_node):
|
|
|
57 # return
|
|
|
58 if drag_obj == self:
|
|
|
59 return
|
|
|
60 opt = wx.MessageBox("Add node as child?","Container Node",wx.YES_NO|wx.CANCEL)
|
|
|
61 if opt == wx.YES:
|
|
|
62 xml_dom = self.tree.drag_obj.delete()
|
|
28
|
63 xml_dom = self.xml.insertBefore(xml_dom,None)
|
|
17
|
64 self.tree.load_xml(xml_dom, self.mytree_node)
|
|
|
65 self.tree.Expand(self.mytree_node)
|
|
|
66 elif opt == wx.NO:
|
|
|
67 node_handler.on_drop(self,evt)
|
|
|
68
|
|
|
69 def tohtml(self):
|
|
|
70 cookie = 0
|
|
|
71 html_str = "<table border=\"1\" ><tr><td>"
|
|
28
|
72 html_str += "<b>"+self.xml.get("name") + "</b>"
|
|
17
|
73 html_str += "</td></tr>\n"
|
|
|
74 html_str += "<tr><td>"
|
|
|
75 max = tree.GetChildrenCount(handler.mytree_node)
|
|
28
|
76 try: (child,cookie)=self.tree.GetFirstChild(self.mytree_node,cookie)
|
|
|
77 except: (child,cookie)=self.tree.GetFirstChild(self.mytree_node)
|
|
17
|
78 obj = self.tree.GetPyData(child)
|
|
|
79 for m in xrange(max):
|
|
|
80 html_str += "<p>" + obj.tohtml()
|
|
|
81 if m < max-1:
|
|
|
82 child = self.tree.GetNextSibling(child)
|
|
|
83 obj = self.tree.GetPyData(child)
|
|
|
84 html_str += "</td></tr></table>"
|
|
|
85 return html_str
|
|
|
86
|
|
|
87 def get_size_constraint(self):
|
|
|
88 return 1
|
|
|
89
|
|
|
90 def get_char_name( self ):
|
|
|
91 return self.child_handlers['general'].get_char_name()
|
|
|
92
|
|
|
93 def get_char_lvl( self, attr ):
|
|
|
94 return self.child_handlers['classes'].get_char_lvl(attr)
|
|
|
95
|
|
|
96
|
|
|
97 class SWd20char_handler(node_handler):
|
|
|
98 """ Node handler for a SWd20 charactor
|
|
|
99 <nodehandler name='?' module='StarWarsd20' class='SWd20char_handler' />
|
|
|
100 """
|
|
|
101 def __init__(self,xml_dom,tree_node):
|
|
|
102 node_handler.__init__(self,xml_dom,tree_node)
|
|
18
|
103 self.frame = component.get('frame')
|
|
17
|
104 self.child_handlers = {}
|
|
|
105 self.new_child_handler('howtouse','HowTO use this tool',SWd20howto,'note')
|
|
|
106 self.new_child_handler('general','General Information',SWd20general,'gear')
|
|
|
107 self.new_child_handler('inventory','Money and Inventory',SWd20inventory,'money')
|
|
|
108 self.new_child_handler('abilities','Abilities Scores',SWd20ability,'gear')
|
|
|
109 self.new_child_handler('classes','Classes',SWd20classes,'knight')
|
|
|
110 self.new_child_handler('saves','Saves',SWd20saves,'skull')
|
|
|
111 self.new_child_handler('skills','Skills',SWd20skill,'book')
|
|
|
112 self.new_child_handler('feats','Feats',SWd20feats,'book')
|
|
|
113 self.new_child_handler('wp','Wound Points',SWd20hp,'gear')
|
|
|
114 self.new_child_handler('vp','Vitality Points',SWd20vp,'gear')
|
|
|
115 self.new_child_handler('attacks','Attacks',SWd20attacks,'spears')
|
|
|
116 self.new_child_handler('ac','Armor',SWd20armor,'spears')
|
|
|
117 self.myeditor = None
|
|
|
118
|
|
|
119
|
|
|
120 def on_version(self,old_version):
|
|
|
121 node_handler.on_version(self,old_version)
|
|
|
122 if old_version == "":
|
|
28
|
123 tree = parse(dir_struct["nodes"]+"StarWars_d20character.xml")
|
|
|
124 xml_dom = tree.getroot()
|
|
17
|
125 ## add new nodes
|
|
|
126 for tag in ("howtouse","inventory","powers","divine","pp"):
|
|
28
|
127 node_list = xml_dom.findall(tag)
|
|
|
128 self.xml.append(node_list[0])
|
|
17
|
129
|
|
|
130 ## add new atts
|
|
28
|
131 melee_attack = self.xml.findall('melee')[0]
|
|
|
132 melee_attack.set("second","0")
|
|
|
133 melee_attack.set("third","0")
|
|
|
134 melee_attack.set("forth","0")
|
|
|
135 melee_attack.set("fifth","0")
|
|
|
136 melee_attack.set("sixth","0")
|
|
|
137 range_attack = self.xml.findall('ranged')[0]
|
|
|
138 range_attack.set("second","0")
|
|
|
139 range_attack.set("third","0")
|
|
|
140 range_attack.set("forth","0")
|
|
|
141 range_attack.set("fifth","0")
|
|
|
142 range_attack.set("sixth","0")
|
|
|
143 gen_list = self.xml.findall('general')[0]
|
|
17
|
144
|
|
|
145 for tag in ("currentxp","xptolevel"):
|
|
28
|
146 node_list = xml_dom.findall(tag)
|
|
|
147 gen_list.append(node_list[0])
|
|
17
|
148 print old_version
|
|
|
149
|
|
|
150
|
|
|
151 def get_char_name( self ):
|
|
|
152 return self.child_handlers['general'].get_char_name()
|
|
|
153
|
|
|
154 def get_char_lvl( self, attr ):
|
|
|
155 return self.child_handlers['classes'].get_char_lvl(attr)
|
|
|
156
|
|
|
157
|
|
|
158 def new_child_handler(self,tag,text,handler_class,icon='gear'):
|
|
28
|
159 node_list = self.xml.findall(tag)
|
|
17
|
160 tree = self.tree
|
|
|
161 i = self.tree.icons[icon]
|
|
|
162 new_tree_node = tree.AppendItem(self.mytree_node,text,i,i)
|
|
|
163 handler = handler_class(node_list[0],new_tree_node,self)
|
|
|
164 tree.SetPyData(new_tree_node,handler)
|
|
|
165 self.child_handlers[tag] = handler
|
|
|
166
|
|
|
167 def get_design_panel(self,parent):
|
|
|
168 return tabbed_panel(parent,self,1)
|
|
|
169
|
|
|
170
|
|
|
171 def get_use_panel(self,parent):
|
|
|
172 return tabbed_panel(parent,self,2)
|
|
|
173
|
|
|
174 def tohtml(self):
|
|
|
175 html_str = "<table><tr><td colspan=2 >"+self.child_handlers['general'].tohtml()+"</td></tr>"
|
|
|
176 html_str += "<tr><td width='50%' valign=top >"+self.child_handlers['abilities'].tohtml()
|
|
|
177 html_str += "<P>" + self.child_handlers['saves'].tohtml()
|
|
|
178 html_str += "<P>" + self.child_handlers['attacks'].tohtml()
|
|
|
179 html_str += "<P>" + self.child_handlers['ac'].tohtml()
|
|
|
180 html_str += "<P>" + self.child_handlers['feats'].tohtml()
|
|
|
181 html_str += "<P>" + self.child_handlers['inventory'].tohtml() +"</td>"
|
|
|
182 html_str += "<td width='50%' valign=top >"+self.child_handlers['classes'].tohtml()
|
|
|
183 html_str += "<P>" + self.child_handlers['wp'].tohtml()
|
|
|
184 html_str += "<P>" + self.child_handlers['vp'].tohtml()
|
|
|
185 html_str += "<P>" + self.child_handlers['skills'].tohtml() +"</td>"
|
|
|
186 html_str += "</tr></table>"
|
|
|
187 return html_str
|
|
|
188
|
|
|
189 def about(self):
|
|
28
|
190 """html_str = "<img src='" + dir_struct["icon"]+'d20_logo.gif' "><br /><b>d20 Character Tool v0.7 beta</b>"
|
|
17
|
191 html_str += "<br />by Chris Davis<br />chris@rpgarchive.com"
|
|
28
|
192 return html_str"""
|
|
|
193 text = 'd20 Character Tool 0.7 beta\n'
|
|
|
194 text += 'by Chris Davis chris@rpgarchive.com'
|
|
|
195 return text
|
|
17
|
196
|
|
|
197 def get_char_name( self ):
|
|
|
198 return self.child_handlers['general'].get_char_name()
|
|
|
199 def get_armor_class( self ):
|
|
|
200 return self.child_handlers['ac'].get_armor_class()
|
|
|
201 def get_max_hp( self ):
|
|
|
202 return self.child_handlers['wp'].get_max_hp()
|
|
|
203 def get_current_hp( self ):
|
|
|
204 return self.child_handlers['wp'].get_current_hp()
|
|
|
205 def get_max_vp( self ):
|
|
|
206 return self.child_handlers['vp'].get_max_vp()
|
|
|
207 def get_current_vp( self ):
|
|
|
208 return self.child_handlers['vp'].get_current_vp()
|
|
|
209 def get_char_lvl( self, attr ):
|
|
|
210 return self.child_handlers['classes'].get_char_lvl(attr)
|
|
|
211
|
|
28
|
212 """ Removed to use the supplied Tabbed Panel
|
|
17
|
213 class tabbed_panel(wx.Notebook):
|
|
|
214 def __init__(self, parent, handler, mode):
|
|
|
215 wx.Notebook.__init__(self, parent, -1, size=(1200,800))
|
|
|
216 self.handler = handler
|
|
|
217 self.parent = parent
|
|
|
218 tree = self.handler.tree
|
|
|
219 max = tree.GetChildrenCount(handler.mytree_node, False)
|
|
|
220 cookie = 0
|
|
|
221 try:
|
|
|
222 (child,cookie)=tree.GetFirstChild(handler.mytree_node,cookie)
|
|
|
223 except: # If this happens we probably have a newer version of wxPython
|
|
|
224 (child,cookie)=tree.GetFirstChild(handler.mytree_node)
|
|
|
225 obj = tree.GetPyData(child)
|
|
|
226 for m in xrange(max):
|
|
|
227
|
|
28
|
228 if mode == 1: panel = obj.get_design_panel(self)
|
|
|
229 else: panel = obj.get_use_panel(self)
|
|
|
230 name = obj.xml.get("name")
|
|
|
231 if panel: self.AddPage(panel,name)
|
|
17
|
232 if m < max-1:
|
|
|
233 child = tree.GetNextSibling(child)
|
|
|
234 obj = tree.GetPyData(child)
|
|
|
235
|
|
|
236 def about(self):
|
|
18
|
237 html_str = "<img src='" + dir_struct["icon"]+'d20_logo.gif' "><br /><b>d20 Character Tool v0.7 beta</b>"
|
|
17
|
238 html_str += "<br />by Chris Davis<br />chris@rpgarchive.com"
|
|
|
239 return html_str
|
|
|
240
|
|
|
241 def get_char_name( self ):
|
|
|
242 return self.child_handlers['general'].get_char_name()
|
|
|
243
|
|
|
244 def get_char_lvl( self, attr ):
|
|
|
245 return self.child_handlers['classes'].get_char_lvl(attr)
|
|
28
|
246 """
|
|
17
|
247
|
|
|
248 class SWd20_char_child(node_handler):
|
|
|
249 """ Node Handler for skill. This handler will be
|
|
|
250 created by SWd20char_handler.
|
|
|
251 """
|
|
|
252 def __init__(self, xml_dom, tree_node, parent):
|
|
28
|
253 node_handler.__init__(self, xml_dom, tree_node)
|
|
17
|
254 self.char_hander = parent
|
|
|
255 self.drag = False
|
|
18
|
256 self.frame = component.get('frame')
|
|
17
|
257 self.myeditor = None
|
|
|
258
|
|
28
|
259 def on_drop(self, evt):
|
|
17
|
260 pass
|
|
|
261
|
|
28
|
262 def on_rclick(self, evt):
|
|
17
|
263 pass
|
|
|
264
|
|
28
|
265 def on_ldclick(self, evt):
|
|
|
266 return
|
|
17
|
267
|
|
28
|
268 def on_html(self, evt):
|
|
17
|
269 html_str = self.tohtml()
|
|
|
270 wnd = http_html_window(self.frame.note,-1)
|
|
28
|
271 wnd.title = self.xml.get('name')
|
|
17
|
272 self.frame.add_panel(wnd)
|
|
|
273 wnd.SetPage(html_str)
|
|
|
274
|
|
28
|
275 def get_design_panel(self, parent):
|
|
17
|
276 pass
|
|
|
277
|
|
28
|
278 def get_use_panel(self, parent):
|
|
17
|
279 return self.get_design_panel(parent)
|
|
|
280
|
|
|
281 def delete(self):
|
|
|
282 pass
|
|
|
283
|
|
|
284
|
|
|
285 class SWd20skill(SWd20_char_child):
|
|
|
286 """ Node Handler for skill. This handler will be
|
|
|
287 created by SWd20char_handler.
|
|
|
288 """
|
|
|
289 def __init__(self, xml_dom, tree_node, parent):
|
|
|
290 SWd20_char_child.__init__(self, xml_dom, tree_node, parent)
|
|
|
291 tree = self.tree
|
|
|
292 icons = self.tree.icons
|
|
28
|
293 node_list = self.xml.findall('skill')
|
|
17
|
294 self.skills={}
|
|
|
295 for n in node_list:
|
|
28
|
296 name = n.get('name')
|
|
17
|
297 self.skills[name] = n
|
|
|
298 new_tree_node = tree.AppendItem(self.mytree_node,name,icons['gear'],icons['gear'])
|
|
|
299 tree.SetPyData(new_tree_node,self)
|
|
|
300
|
|
|
301 def get_mod(self,name):
|
|
|
302 skill = self.skills[name]
|
|
28
|
303 stat = skill.get('stat')
|
|
|
304 ac = int(skill.get('armorcheck'))
|
|
17
|
305 if ac:
|
|
|
306 ac = self.char_hander.child_handlers['ac'].get_check_pen()
|
|
|
307 stat_mod = self.char_hander.child_handlers['abilities'].get_mod(stat)
|
|
28
|
308 rank = int(skill.get('rank'))
|
|
|
309 misc = int(skill.get('misc'))
|
|
17
|
310 total = stat_mod + rank + misc + ac
|
|
|
311 return total
|
|
|
312
|
|
|
313 def on_rclick(self,evt):
|
|
|
314 #updated with code for untrained use check
|
|
|
315 item = self.tree.GetSelection()
|
|
|
316 name = self.tree.GetItemText(item)
|
|
|
317 skill = self.skills[name]
|
|
28
|
318 rank = int(skill.get('rank'))
|
|
|
319 untrained = int(skill.get('untrained'))
|
|
17
|
320 chat = self.chat
|
|
|
321 if item == self.mytree_node:
|
|
|
322 SWd20_char_child.on_ldclick(self,evt)
|
|
|
323 else:
|
|
28
|
324 if rank == 0 and untrained == 0: chat.Post("Can't use untrained!",True,True)
|
|
17
|
325 else:
|
|
|
326 mod = self.get_mod(name)
|
|
28
|
327 if mod >= 0: mod1 = "+"
|
|
|
328 else: mod1 = ""
|
|
17
|
329 txt = '%s Skill Check: [1d20%s%s]' % (name, mod1, mod)
|
|
|
330 chat.ParsePost(txt,True,True)
|
|
|
331
|
|
|
332 def get_design_panel(self,parent):
|
|
|
333 wnd = outline_panel(parent,self,skill_grid,"Skills")
|
|
|
334 wnd.title = "Skills (edit)"
|
|
|
335 return wnd
|
|
|
336
|
|
|
337 def tohtml(self):
|
|
|
338 html_str = """<table border='1' width=100% ><tr BGCOLOR=#E9E9E9 ><th width='30%'>Skill</th><th>Key</th>
|
|
|
339 <th>Rank</th><th>Abil</th><th>Misc</th><th>Total</th></tr>"""
|
|
28
|
340 node_list = self.xml.findall('skill')
|
|
17
|
341 for n in node_list:
|
|
28
|
342 name = n.get('name')
|
|
|
343 stat = n.get('stat')
|
|
|
344 rank = n.get('rank')
|
|
17
|
345 html_str = html_str + "<tr ALIGN='center'><td>"+name+"</td><td>"+stat+"</td><td>"+rank+"</td>"
|
|
|
346 stat_mod = str(self.char_hander.child_handlers['abilities'].get_mod(stat))
|
|
28
|
347 misc = n.get('misc')
|
|
17
|
348 mod = str(self.get_mod(name))
|
|
28
|
349 if mod >= 0: mod1 = "+"
|
|
|
350 else: mod1 = ""
|
|
17
|
351 html_str = html_str + "<td>"+stat_mod+"</td><td>"+misc+'</td><td>%s%s</td></tr>' % (mod1, mod)
|
|
|
352 html_str = html_str + "</table>"
|
|
|
353 return html_str
|
|
|
354
|
|
|
355
|
|
|
356 class SWd20ability(SWd20_char_child):
|
|
|
357 """ Node Handler for ability. This handler will be
|
|
|
358 created by SWd20char_handler.
|
|
|
359 """
|
|
|
360 def __init__(self, xml_dom, tree_node, parent):
|
|
|
361 SWd20_char_child.__init__(self, xml_dom, tree_node, parent)
|
|
|
362 self.abilities = {}
|
|
28
|
363 node_list = self.xml.findall('stat')
|
|
17
|
364 tree = self.tree
|
|
|
365 icons = tree.icons
|
|
|
366 for n in node_list:
|
|
28
|
367 name = n.get('abbr')
|
|
17
|
368 self.abilities[name] = n
|
|
|
369 new_tree_node = tree.AppendItem( self.mytree_node, name, icons['gear'], icons['gear'] )
|
|
|
370 tree.SetPyData( new_tree_node, self )
|
|
|
371
|
|
|
372 def on_rclick( self, evt ):
|
|
|
373 item = self.tree.GetSelection()
|
|
|
374 name = self.tree.GetItemText( item )
|
|
|
375 if item == self.mytree_node:
|
|
|
376 SWd20_char_child.on_ldclick( self, evt )
|
|
|
377 else:
|
|
|
378 mod = self.get_mod( name )
|
|
28
|
379 if mod >= 0: mod1 = "+"
|
|
|
380 else: mod1 = ""
|
|
17
|
381 chat = self.chat
|
|
|
382 txt = '%s check: [1d20%s%s]' % ( name, mod1, mod )
|
|
|
383 chat.ParsePost( txt, True, True )
|
|
|
384
|
|
|
385 def get_mod(self,abbr):
|
|
28
|
386 score = int(self.abilities[abbr].get('base'))
|
|
17
|
387 mod = (score - 10) / 2
|
|
|
388 return mod
|
|
|
389
|
|
|
390 def set_score(self,abbr,score):
|
|
|
391 if score >= 0:
|
|
28
|
392 self.abilities[abbr].set("base",str(score))
|
|
17
|
393
|
|
|
394 def get_design_panel(self,parent):
|
|
|
395 wnd = outline_panel(parent,self,abil_grid,"Abilities")
|
|
|
396 wnd.title = "Abilities (edit)"
|
|
|
397 return wnd
|
|
|
398
|
|
|
399 def tohtml(self):
|
|
|
400 html_str = """<table border='1' width=100%><tr BGCOLOR=#E9E9E9 ><th width='50%'>Ability</th>
|
|
|
401 <th>Base</th><th>Modifier</th></tr>"""
|
|
28
|
402 node_list = self.xml.findall('stat')
|
|
17
|
403 for n in node_list:
|
|
28
|
404 name = n.get('name')
|
|
|
405 abbr = n.get('abbr')
|
|
|
406 base = n.get('base')
|
|
17
|
407 mod = str(self.get_mod(abbr))
|
|
28
|
408 if mod >= 0: mod1 = "+"
|
|
|
409 else: mod1 = ""
|
|
17
|
410 html_str = html_str + "<tr ALIGN='center'><td>"+name+"</td><td>"+base+'</td><td>%s%s</td></tr>' % (mod1, mod)
|
|
|
411 html_str = html_str + "</table>"
|
|
|
412 return html_str
|
|
|
413
|
|
|
414 class SWd20saves(SWd20_char_child):
|
|
|
415 """ Node Handler for saves. This handler will be
|
|
|
416 created by SWd20char_handler.
|
|
|
417 """
|
|
|
418 def __init__(self, xml_dom, tree_node, parent):
|
|
|
419 SWd20_char_child.__init__(self, xml_dom, tree_node, parent)
|
|
|
420 tree = self.tree
|
|
|
421 icons = self.tree.icons
|
|
28
|
422 node_list = self.xml.findall('save')
|
|
17
|
423 self.saves={}
|
|
|
424 for n in node_list:
|
|
28
|
425 name = n.get('name')
|
|
17
|
426 self.saves[name] = n
|
|
|
427 new_tree_node = tree.AppendItem(self.mytree_node,name,icons['gear'],icons['gear'])
|
|
|
428 tree.SetPyData(new_tree_node,self)
|
|
|
429
|
|
|
430 def get_mod(self,name):
|
|
|
431 save = self.saves[name]
|
|
28
|
432 stat = save.get('stat')
|
|
17
|
433 stat_mod = self.char_hander.child_handlers['abilities'].get_mod(stat)
|
|
28
|
434 base = int(save.get('base'))
|
|
|
435 miscmod = int(save.get('miscmod'))
|
|
17
|
436 total = stat_mod + base + miscmod
|
|
|
437 return total
|
|
|
438
|
|
|
439 def on_rclick(self,evt):
|
|
|
440 item = self.tree.GetSelection()
|
|
|
441 name = self.tree.GetItemText(item)
|
|
|
442 if item == self.mytree_node:
|
|
|
443 SWd20_char_child.on_ldclick(self,evt)
|
|
|
444 #wnd = save_grid(self.frame.note,self)
|
|
|
445 #wnd.title = "Saves"
|
|
|
446 #self.frame.add_panel(wnd)
|
|
|
447 else:
|
|
|
448 mod = self.get_mod(name)
|
|
28
|
449 if mod >= 0: mod1 = "+"
|
|
|
450 else: mod1 = ""
|
|
17
|
451 chat = self.chat
|
|
|
452 txt = '%s save: [1d20%s%s]' % (name, mod1, mod)
|
|
|
453 chat.ParsePost( txt, True, True )
|
|
|
454
|
|
|
455 def get_design_panel(self,parent):
|
|
|
456 wnd = outline_panel(parent,self,save_grid,"Saves")
|
|
|
457 wnd.title = "Saves"
|
|
|
458 return wnd
|
|
|
459
|
|
|
460 def tohtml(self):
|
|
|
461 html_str = """<table border='1' width=100% ><tr BGCOLOR=#E9E9E9 ><th width='30%'>Save</th>
|
|
|
462 <th>Key</th><th>Base</th><th>Abil</th><th>Magic</th>
|
|
|
463 <th>Misc</th><th>Total</th></tr>"""
|
|
28
|
464 node_list = self.xml.findall('save')
|
|
17
|
465 for n in node_list:
|
|
28
|
466 name = n.get('name')
|
|
|
467 stat = n.get('stat')
|
|
|
468 base = n.get('base')
|
|
17
|
469 html_str = html_str + "<tr ALIGN='center'><td>"+name+"</td><td>"+stat+"</td><td>"+base+"</td>"
|
|
|
470 stat_mod = str(self.char_hander.child_handlers['abilities'].get_mod(stat))
|
|
28
|
471 mag = n.get('magmod')
|
|
|
472 misc = n.get('miscmod')
|
|
17
|
473 mod = str(self.get_mod(name))
|
|
28
|
474 if mod >= 0: mod1 = "+"
|
|
|
475 else: mod1 = ""
|
|
17
|
476 html_str = html_str + "<td>"+stat_mod+"</td><td>"+mag+"</td>"
|
|
|
477 html_str = html_str + '<td>'+misc+'</td><td>%s%s</td></tr>' % (mod1, mod)
|
|
|
478 html_str = html_str + "</table>"
|
|
|
479 return html_str
|
|
|
480
|
|
|
481
|
|
|
482 class SWd20general(SWd20_char_child):
|
|
|
483 """ Node Handler for general information. This handler will be
|
|
|
484 created by SWd20char_handler.
|
|
|
485 """
|
|
|
486 def __init__(self, xml_dom, tree_node, parent):
|
|
|
487 SWd20_char_child.__init__(self, xml_dom, tree_node, parent)
|
|
|
488
|
|
|
489 def get_design_panel(self,parent):
|
|
|
490 wnd = outline_panel(parent,self,gen_grid,"General Information")
|
|
|
491 wnd.title = "General Info"
|
|
|
492 return wnd
|
|
|
493
|
|
|
494 def tohtml(self):
|
|
28
|
495 n_list = self.xml.getchildren()
|
|
17
|
496 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>General Information</th></tr><tr><td>"
|
|
|
497 for n in n_list:
|
|
28
|
498 html_str += "<B>"+n.tag.capitalize() +":</B> "
|
|
|
499 html_str += n.text + ", "
|
|
17
|
500 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
501 return html_str
|
|
|
502
|
|
|
503 def on_name_change(self,name):
|
|
|
504 self.char_hander.rename(name)
|
|
|
505
|
|
|
506 def get_char_name( self ):
|
|
28
|
507 node = self.xml.findall( 'name' )[0]
|
|
|
508 return node.text
|
|
17
|
509
|
|
|
510
|
|
|
511 class SWd20classes(SWd20_char_child):
|
|
|
512 """ Node Handler for classes. This handler will be
|
|
|
513 created by SWd20char_handler.
|
|
|
514 """
|
|
|
515 def __init__(self, xml_dom, tree_node, parent):
|
|
|
516 SWd20_char_child.__init__(self, xml_dom, tree_node, parent)
|
|
|
517
|
|
|
518 def get_design_panel(self,parent):
|
|
|
519 wnd = outline_panel(parent,self,class_panel,"Classes")
|
|
|
520 wnd.title = "Classes"
|
|
|
521 return wnd
|
|
|
522
|
|
|
523 def tohtml(self):
|
|
|
524 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>Classes</th></tr><tr><td>"
|
|
28
|
525 n_list = self.xml.getchildren()
|
|
|
526 for n in n_list: html_str += n.get('name') + " ("+n.get('level')+"), "
|
|
17
|
527 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
528 return html_str
|
|
|
529
|
|
|
530 def get_char_lvl( self, attr ):
|
|
28
|
531 node_list = self.xml.findall('class')
|
|
17
|
532 for n in node_list:
|
|
28
|
533 lvl = n.get('level')
|
|
|
534 type = n.get('name')
|
|
|
535 if attr == "level": return lvl
|
|
|
536 elif attr == "class": return type
|
|
17
|
537
|
|
|
538
|
|
|
539 class SWd20feats(SWd20_char_child):
|
|
|
540 """ Node Handler for classes. This handler will be
|
|
|
541 created by d20char_handler.
|
|
|
542 """
|
|
|
543 def __init__(self, xml_dom, tree_node, parent):
|
|
|
544 SWd20_char_child.__init__(self, xml_dom, tree_node, parent)
|
|
|
545
|
|
|
546 def get_design_panel(self,parent):
|
|
|
547 wnd = outline_panel(parent,self,feat_panel,"Feats")
|
|
|
548 wnd.title = "Feats"
|
|
|
549 return wnd
|
|
|
550
|
|
|
551 def tohtml(self):
|
|
|
552 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>Feats</th></tr><tr><td>"
|
|
28
|
553 n_list = self.xml.getchildren()
|
|
|
554 for n in n_list: html_str += n.get('name')+ ", "
|
|
17
|
555 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
556 return html_str
|
|
|
557
|
|
|
558 class SWd20howto(SWd20_char_child):
|
|
|
559 """ Node Handler for hit points. This handler will be
|
|
|
560 created by d20char_handler.
|
|
|
561 """
|
|
|
562 def __init__(self, xml_dom, tree_node, parent):
|
|
|
563 SWd20_char_child.__init__(self, xml_dom, tree_node, parent)
|
|
|
564
|
|
|
565 def get_design_panel(self,parent):
|
|
|
566 wnd = outline_panel(parent,self,howto_panel,"How To")
|
|
|
567 wnd.title = "How To"
|
|
|
568 return wnd
|
|
|
569
|
|
|
570 class SWd20inventory(SWd20_char_child):
|
|
|
571 """ Node Handler for general information. This handler will be
|
|
|
572 created by d20char_handler.
|
|
|
573 """
|
|
|
574 def __init__(self, xml_dom, tree_node, parent):
|
|
|
575 SWd20_char_child.__init__(self, xml_dom, tree_node, parent)
|
|
|
576
|
|
|
577 def get_design_panel(self,parent):
|
|
|
578 wnd = outline_panel(parent,self,inventory_grid,"Inventory")
|
|
|
579 wnd.title = "General Info"
|
|
|
580 return wnd
|
|
|
581
|
|
|
582 def tohtml(self):
|
|
28
|
583 n_list = self.xml.getchildren()
|
|
17
|
584 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>General Information</th></tr><tr><td>"
|
|
|
585 for n in n_list:
|
|
28
|
586 html_str += "<B>"+n.tag.capitalize() +":</B> "
|
|
|
587 html_str += n.text + "<br />"
|
|
17
|
588 html_str = html_str[:len(html_str)-2] + "</td></tr></table>"
|
|
|
589 return html_str
|
|
|
590
|
|
|
591 def on_name_change(self,name):
|
|
|
592 self.char_hander.rename(name)
|
|
|
593
|
|
|
594 def get_char_name( self ):
|
|
28
|
595 node = self.xml.findall( 'name' )[0]
|
|
|
596 return node.text
|
|
17
|
597
|
|
|
598 class SWd20hp(SWd20_char_child):
|
|
|
599 """ Node Handler for hit points. This handler will be
|
|
|
600 created by d20char_handler.
|
|
|
601 """
|
|
|
602 def __init__(self,xml_dom,tree_node,parent):
|
|
|
603 SWd20_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
604
|
|
|
605 def get_design_panel(self,parent):
|
|
|
606 wnd = outline_panel(parent,self,hp_panel,"Wound Points")
|
|
|
607 wnd.title = "Wound Points"
|
|
|
608 return wnd
|
|
|
609
|
|
|
610 def tohtml(self):
|
|
|
611 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th colspan=4>Wound Points</th></tr>"
|
|
28
|
612 html_str += "<tr><th>Max:</th><td>"+self.xml.get('max')+"</td>"
|
|
|
613 html_str += "<th>Current:</th><td>"+self.xml.get('current')+"</td>"
|
|
17
|
614 html_str += "</tr></table>"
|
|
|
615 return html_str
|
|
|
616
|
|
|
617 def get_max_hp( self ):
|
|
28
|
618 try: return eval( self.xml.get( 'max' ) )
|
|
|
619 except: return 0
|
|
17
|
620 def get_current_hp( self ):
|
|
28
|
621 try: return eval( self.xml.get( 'current' ) )
|
|
|
622 except: return 0
|
|
17
|
623
|
|
|
624 class SWd20vp(SWd20_char_child):
|
|
|
625 """ Node Handler for hit points. This handler will be
|
|
|
626 created by d20char_handler.
|
|
|
627 """
|
|
|
628 def __init__(self,xml_dom,tree_node,parent):
|
|
|
629 SWd20_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
630
|
|
|
631 def get_design_panel(self,parent):
|
|
|
632 wnd = outline_panel(parent,self,vp_panel,"Vitality Points")
|
|
|
633 wnd.title = "Vitality Points"
|
|
|
634 return wnd
|
|
|
635
|
|
|
636 def tohtml(self):
|
|
|
637 html_str = "<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th colspan=4>Vitality Points</th></tr>"
|
|
28
|
638 html_str += "<tr><th>Max:</th><td>"+self.xml.get('max')+"</td>"
|
|
|
639 html_str += "<th>Current:</th><td>"+self.xml.get('current')+"</td>"
|
|
17
|
640 html_str += "</tr></table>"
|
|
|
641 return html_str
|
|
|
642
|
|
|
643 def get_max_vp( self ):
|
|
28
|
644 try: return eval( self.xml.get( 'max' ) )
|
|
|
645 except: return 0
|
|
17
|
646 def get_current_vp( self ):
|
|
28
|
647 try: return eval( self.xml.get( 'current' ) )
|
|
|
648 except: return 0
|
|
17
|
649
|
|
|
650 class SWd20attacks(SWd20_char_child):
|
|
|
651 """ Node Handler for attacks. This handler will be
|
|
|
652 created by d20char_handler.
|
|
|
653 """
|
|
|
654 def __init__(self,xml_dom,tree_node,parent):
|
|
|
655 SWd20_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
28
|
656 node_list = self.xml.findall('melee')
|
|
17
|
657 self.melee = node_list[0]
|
|
28
|
658 node_list = self.xml.findall('ranged')
|
|
17
|
659 self.ranged = node_list[0]
|
|
|
660 self.refresh_weapons()
|
|
|
661
|
|
|
662 def refresh_weapons(self):
|
|
|
663 self.weapons = {}
|
|
|
664 tree = self.tree
|
|
|
665 icons = self.tree.icons
|
|
|
666 tree.CollapseAndReset(self.mytree_node)
|
|
28
|
667 node_list = self.xml.findall('weapon')
|
|
17
|
668 for n in node_list:
|
|
28
|
669 name = n.get('name')
|
|
17
|
670 new_tree_node = tree.AppendItem(self.mytree_node,name,icons['sword'],icons['sword'])
|
|
|
671 tree.SetPyData(new_tree_node,self)
|
|
|
672 self.weapons[name]=n
|
|
|
673
|
|
|
674 def get_mod(self,type='m'):
|
|
|
675 (base, base2, base3, base4, base5, base6, stat_mod, misc) = self.get_attack_data(type)
|
|
|
676 return base + misc + stat_mod
|
|
|
677
|
|
|
678 def get_attack_data(self,type='m'):
|
|
|
679 if type=='m' or type=='0':
|
|
|
680 stat_mod = self.char_hander.child_handlers['abilities'].get_mod('Str')
|
|
|
681 temp = self.melee
|
|
|
682 else:
|
|
|
683 stat_mod = self.char_hander.child_handlers['abilities'].get_mod('Dex')
|
|
|
684 temp = self.ranged
|
|
28
|
685 base = int(temp.get('base'))
|
|
|
686 base2 = int(temp.get('second'))
|
|
|
687 base3 = int(temp.get('third'))
|
|
|
688 base4 = int(temp.get('forth'))
|
|
|
689 base5 = int(temp.get('fifth'))
|
|
|
690 base6 = int(temp.get('sixth'))
|
|
|
691 misc = int(temp.get('misc'))
|
|
17
|
692 return (base, base2, base3, base4, base5, base6, stat_mod ,misc)
|
|
|
693
|
|
|
694 def on_rclick(self,evt):
|
|
|
695 #removed the DnD specific code
|
|
|
696 item = self.tree.GetSelection()
|
|
|
697 name = self.tree.GetItemText(item)
|
|
|
698 if item == self.mytree_node:
|
|
|
699 SWd20_char_child.on_ldclick(self,evt)
|
|
|
700 #self.frame.add_panel(self.get_design_panel(self.frame.note))
|
|
|
701 else:
|
|
28
|
702 mod = int(self.weapons[name].get('mod'))
|
|
|
703 if self.weapons[name].get('range') == '0':
|
|
17
|
704 mod = mod + self.get_mod('m')
|
|
28
|
705 if mod >= 0: mod1 = "+"
|
|
|
706 else: mod1 = ""
|
|
17
|
707 else:
|
|
|
708 mod = mod + self.get_mod('r')
|
|
28
|
709 if mod >= 0: mod1 = "+"
|
|
|
710 else: mod1 = ""
|
|
17
|
711 chat = self.chat
|
|
28
|
712 dmg = self.weapons[name].get('damage')
|
|
17
|
713 lvl = self.get_char_lvl('level')
|
|
|
714 cname = self.char_hander.get_char_name()
|
|
|
715 txt = '%s %s Attack Roll: [1d20%s%s] ===> DMG: [%s%s%s]' % (cname, name, mod1, mod, dmg, mod1, mod)
|
|
|
716 chat.ParsePost( txt, True, False )
|
|
|
717 temp = self.melee
|
|
|
718 stat_mod = self.char_hander.child_handlers['abilities'].get_mod('Str')
|
|
|
719
|
|
|
720 def get_design_panel(self,parent):
|
|
|
721 wnd = outline_panel(parent,self,attack_panel,"Attacks")
|
|
|
722 wnd.title = "Attacks"
|
|
|
723 return wnd
|
|
|
724
|
|
|
725 def get_char_lvl( self, attr ):
|
|
|
726 return self.char_hander.get_char_lvl(attr)
|
|
|
727
|
|
|
728 def tohtml(self):
|
|
|
729 melee = self.get_attack_data('m')
|
|
|
730 ranged = self.get_attack_data('r')
|
|
|
731 html_str = """<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>Attack</th>
|
|
|
732 <th>Total</th><th >Base</th><th>Abil</th><th>Misc</th></tr>"""
|
|
|
733 html_str += "<tr ALIGN='center' ><th >Melee:</th>"
|
|
|
734 html_str += "<td>"+str(melee[0]+melee[1]+melee[2])+"</td>"
|
|
|
735 html_str += "<td>"+str(melee[0])+"</td>"
|
|
|
736 html_str += "<td>"+str(melee[1])+"</td>"
|
|
|
737 html_str += "<td>"+str(melee[2])+"</td></tr>"
|
|
|
738
|
|
|
739 html_str += "<tr ALIGN='center' ><th >Ranged:</th>"
|
|
|
740 html_str += "<td>"+str(ranged[0]+ranged[1]+ranged[2])+"</td>"
|
|
|
741 html_str += "<td>"+str(ranged[0])+"</td>"
|
|
|
742 html_str += "<td>"+str(ranged[1])+"</td>"
|
|
|
743 html_str += "<td>"+str(ranged[2])+"</td></tr></table>"
|
|
|
744
|
|
28
|
745 n_list = self.xml.findall('weapon')
|
|
17
|
746 for n in n_list:
|
|
28
|
747 mod = n.get('mod')
|
|
|
748 if mod >= 0: mod1 = "+"
|
|
|
749 else: mod1 = ""
|
|
|
750 ran = n.get('range')
|
|
17
|
751 total = str(int(mod) + self.get_mod(ran))
|
|
|
752 html_str += """<P><table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th colspan=2>Weapon</th>
|
|
|
753 <th>Attack</th><th >Damage</th><th>Critical</th></tr>"""
|
|
28
|
754 html_str += "<tr ALIGN='center' ><td colspan=2>"+n.get('name')+"</td><td>"+total+"</td>"
|
|
|
755 html_str += "<td>"+n.get('damage')+"</td><td>"+n.get('critical')+"</td></tr>"
|
|
17
|
756 html_str += """<tr BGCOLOR=#E9E9E9 ><th>Range</th><th>Weight</th>
|
|
|
757 <th>Type</th><th>Size</th><th>Misc Mod</th></tr>"""
|
|
28
|
758 html_str += "<tr ALIGN='center'><td>"+ran+"</td><td>"+n.get('weight')+"</td>"
|
|
|
759 html_str += "<td>"+n.get('type')+"</td><td>"+n.get('size')+"</td>"
|
|
17
|
760 html_str += '<td>%s%s</td></tr></table>' % (mod1, mod)
|
|
|
761 return html_str
|
|
|
762
|
|
|
763 class SWd20armor(SWd20_char_child):
|
|
|
764 """ Node Handler for ac. This handler will be
|
|
|
765 created by d20char_handler.
|
|
|
766 """
|
|
|
767 def __init__(self,xml_dom,tree_node,parent):
|
|
|
768 SWd20_char_child.__init__(self,xml_dom,tree_node,parent)
|
|
|
769
|
|
|
770 def get_total_weight(self):
|
|
|
771 return self.get_total('weight')
|
|
|
772
|
|
|
773 def get_check_pen(self):
|
|
|
774 return self.get_total('checkpenalty')
|
|
|
775
|
|
|
776 def get_armor_class(self):
|
|
|
777 ac_total = 10
|
|
|
778 ac_total += self.get_total('bonus')
|
|
|
779 dex_mod = self.char_hander.child_handlers['abilities'].get_mod('Dex')
|
|
|
780 max_dex = self.get_max_dex()
|
|
28
|
781 if dex_mod < max_dex: ac_total += dex_mod
|
|
|
782 else: ac_total += max_dex
|
|
17
|
783 return ac_total
|
|
|
784
|
|
|
785 def get_max_dex(self):
|
|
28
|
786 armor_list = self.xml.findall('armor')
|
|
17
|
787 dex = 10
|
|
|
788 for a in armor_list:
|
|
28
|
789 temp = int(a.get("maxdex"))
|
|
|
790 if temp < dex: dex = temp
|
|
17
|
791 return dex
|
|
|
792
|
|
|
793 def get_total(self,attr):
|
|
28
|
794 armor_list = self.xml.findall('armor')
|
|
17
|
795 total = 0
|
|
28
|
796 for a in armor_list: total += int(a.get(attr))
|
|
17
|
797 return total
|
|
|
798
|
|
|
799 def get_design_panel(self,parent):
|
|
|
800 wnd = outline_panel(parent,self,ac_panel,"Armor")
|
|
|
801 wnd.title = "Armor"
|
|
|
802 return wnd
|
|
|
803
|
|
|
804 def tohtml(self):
|
|
|
805 html_str = """<table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th>AC</th>
|
|
|
806 <th>Check Penalty</th><th >Spell Failure</th><th>Max Dex</th><th>Total Weight</th></tr>"""
|
|
|
807 html_str += "<tr ALIGN='center' ><td>"+str(self.get_armor_class())+"</td>"
|
|
|
808 html_str += "<td>"+str(self.get_check_pen())+"</td>"
|
|
|
809 html_str += "<td>"+str(self.get_spell_failure())+"</td>"
|
|
|
810 html_str += "<td>"+str(self.get_max_dex())+"</td>"
|
|
|
811 html_str += "<td>"+str(self.get_total_weight())+"</td></tr></table>"
|
|
28
|
812 n_list = self.xml.getchildren()
|
|
17
|
813 for n in n_list:
|
|
|
814 html_str += """<P><table width=100% border=1 ><tr BGCOLOR=#E9E9E9 ><th colspan=3>Armor</th>
|
|
|
815 <th>Type</th><th >Bonus</th></tr>"""
|
|
28
|
816 html_str += "<tr ALIGN='center' ><td colspan=3>"+n.get('name')+"</td>"
|
|
|
817 html_str += "<td>"+n.get('type')+"</td>"
|
|
|
818 html_str += "<td>"+n.get('bonus')+"</td></tr>"
|
|
17
|
819 html_str += """<tr BGCOLOR=#E9E9E9 ><th>Check Penalty</th><th>Spell Failure</th>
|
|
|
820 <th>Max Dex</th><th>Speed</th><th>Weight</th></tr>"""
|
|
28
|
821 html_str += "<tr ALIGN='center'><td>"+n.get('checkpenalty')+"</td>"
|
|
|
822 html_str += "<td>"+n.get('maxdex')+"</td>"
|
|
|
823 html_str += "<td>"+n.get('speed')+"</td>"
|
|
|
824 html_str += "<td>"+n.get('weight')+"</td></tr></table>"
|
|
17
|
825 return html_str
|
|
|
826
|
|
|
827
|
|
|
828 ########################
|
|
|
829 ## d20 char windows
|
|
|
830 ########################
|
|
|
831
|
|
|
832 class base_panel(wx.Panel):
|
|
|
833 def __init__(self, parent):
|
|
|
834 wx.Panel.__init__(self, parent, -1)
|
|
|
835
|
|
|
836 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
837
|
|
|
838 def on_size(self,event):
|
|
|
839 s = self.GetClientSizeTuple()
|
|
|
840
|
|
|
841 class outline_panel(wx.Panel):
|
|
|
842 def __init__(self, parent, handler, wnd, txt,):
|
|
|
843 wx.Panel.__init__(self, parent, -1)
|
|
|
844 self.panel = wnd(self,handler)
|
|
|
845 self.outline = wx.StaticBox(self,-1,txt)
|
|
|
846 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
847
|
|
|
848 def on_size(self,event):
|
|
|
849 s = self.GetClientSizeTuple()
|
|
|
850 self.panel.SetDimensions(20,20,s[0]-40,s[1]-40)
|
|
|
851 self.outline.SetDimensions(5,5,s[0]-10,s[1]-10)
|
|
|
852
|
|
|
853 class char_panel(wx.ScrolledWindow):
|
|
|
854 def __init__(self, parent, handler):
|
|
28
|
855 pname = handler.xml.set("name", 'TWO')
|
|
17
|
856 wx.ScrolledWindow.__init__(self, parent, -1,style=wx.VSCROLL | wx.SUNKEN_BORDER )
|
|
|
857 self.height = 1200
|
|
|
858 self.SetScrollbars(10, 10,80, self.height/10)
|
|
|
859 self.main_sizer = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
860 self.panels = {}
|
|
|
861 keys = handler.child_handlers.keys()
|
|
28
|
862 for k in keys: self.panels[k] = handler.child_handlers[k].get_design_panel(self, [k])
|
|
17
|
863 self.sub_sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
864 self.sub_sizer2 = wx.BoxSizer(wx.VERTICAL)
|
|
|
865 self.sub_sizer.Add(self.panels['general'], 1, wx.EXPAND)
|
|
|
866 self.sub_sizer.Add(self.panels['abilities'], 1, wx.EXPAND)
|
|
|
867
|
|
|
868 self.sub_sizer.Add(self.panels['attacks'], 2, wx.EXPAND)
|
|
|
869 self.sub_sizer.Add(self.panels['ac'], 1, wx.EXPAND)
|
|
|
870
|
|
|
871 self.sub_sizer2.Add(self.panels['classes'], 2, wx.EXPAND)
|
|
|
872 self.sub_sizer2.Add(self.panels['wp'], 1, wx.EXPAND)
|
|
|
873 self.sub_sizer2.Add(self.panels['vp'], 1, wx.EXPAND)
|
|
|
874 self.sub_sizer2.Add(self.panels['saves'], 2, wx.EXPAND)
|
|
|
875
|
|
|
876 self.sub_sizer2.Add(self.panels['feats'], 2, wx.EXPAND)
|
|
|
877 self.sub_sizer2.Add(self.panels['skills'], 3, wx.EXPAND)
|
|
|
878
|
|
|
879 self.main_sizer.Add(self.sub_sizer, 1, wx.EXPAND)
|
|
|
880 self.main_sizer.Add(self.sub_sizer2, 1, wx.EXPAND)
|
|
|
881 self.panels['abilities'].panel.char_wnd = self
|
|
|
882 self.SetSizer(self.main_sizer)
|
|
|
883 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
884
|
|
|
885
|
|
|
886 def on_size(self,evt):
|
|
|
887 s = self.GetClientSizeTuple()
|
|
|
888 self.SetScrollbars(10, 10,s[0]/10, self.height/10)
|
|
|
889 dc = wx.ClientDC(self)
|
|
|
890 x = dc.DeviceToLogicalX(0)
|
|
|
891 y = dc.DeviceToLogicalY(0)
|
|
|
892 self.main_sizer.SetDimension(x,y,s[0],self.height)
|
|
|
893 evt.Skip()
|
|
|
894
|
|
|
895 def refresh_data(self):
|
|
|
896 self.panels['saves'].panel.refresh_data()
|
|
|
897 self.panels['skills'].panel.refresh_data()
|
|
|
898 self.panels['attacks'].panel.refresh_data()
|
|
|
899
|
|
|
900 HOWTO_MAX = wx.NewId()
|
|
|
901
|
|
|
902 class howto_panel(wx.Panel):
|
|
|
903 def __init__(self, parent, handler):
|
|
|
904 wx.Panel.__init__(self, parent, -1)
|
|
28
|
905 pname = handler.xml.set("name", 'How To')
|
|
17
|
906 self.sizer = wx.FlexGridSizer(2, 4, 2, 2) # rows, cols, hgap, vgap
|
|
28
|
907 self.xml = handler.xml
|
|
|
908 n_list = self.xml.getchildren()
|
|
17
|
909 for n in n_list:
|
|
28
|
910 self.sizer.AddMany([ (wx.StaticText(self, -1, n.text), 0, wx.ALIGN_CENTER_VERTICAL),
|
|
17
|
911 ])
|
|
|
912 self.sizer.AddGrowableCol(1)
|
|
|
913 self.SetSizer(self.sizer)
|
|
|
914
|
|
|
915
|
|
|
916 WP_CUR = wx.NewId()
|
|
|
917 WP_MAX = wx.NewId()
|
|
|
918
|
|
|
919 class hp_panel(wx.Panel):
|
|
|
920 def __init__(self, parent, handler):
|
|
|
921 wx.Panel.__init__(self, parent, -1)
|
|
28
|
922 pname = handler.xml.set("name", 'WoundPoints')
|
|
17
|
923 self.sizer = wx.FlexGridSizer(2, 4, 2, 2) # rows, cols, hgap, vgap
|
|
28
|
924 self.xml = handler.xml
|
|
17
|
925 self.sizer.AddMany([ (wx.StaticText(self, -1, "WP Current:"), 0, wx.ALIGN_CENTER_VERTICAL),
|
|
28
|
926 (wx.TextCtrl(self, WP_CUR, self.xml.get('current')), 0, wx.EXPAND),
|
|
17
|
927 (wx.StaticText(self, -1, "WP Max:"), 0, wx.ALIGN_CENTER_VERTICAL),
|
|
28
|
928 (wx.TextCtrl(self, WP_MAX, self.xml.get('max')), 0, wx.EXPAND),
|
|
17
|
929 ])
|
|
|
930 self.sizer.AddGrowableCol(1)
|
|
|
931 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
932 self.Bind(wx.EVT_TEXT, self.on_text, id=WP_MAX)
|
|
|
933 self.Bind(wx.EVT_TEXT, self.on_text, id=WP_CUR)
|
|
|
934 self.SetSizer(self.sizer)
|
|
|
935
|
|
|
936 def on_text(self,evt):
|
|
|
937 id = evt.GetId()
|
|
|
938 if id == WP_CUR:
|
|
28
|
939 self.xml.set('current',evt.GetString())
|
|
17
|
940 elif id == WP_MAX:
|
|
28
|
941 self.xml.set('max',evt.GetString())
|
|
17
|
942
|
|
|
943 def on_size(self,evt):
|
|
|
944 s = self.GetClientSizeTuple()
|
|
|
945 self.sizer.SetDimension(0,0,s[0],s[1])
|
|
|
946
|
|
|
947 VP_CUR = wx.NewId()
|
|
|
948 VP_MAX = wx.NewId()
|
|
|
949
|
|
|
950 class vp_panel(wx.Panel):
|
|
|
951 def __init__(self, parent, handler):
|
|
|
952 wx.Panel.__init__(self, parent, -1)
|
|
28
|
953 pname = handler.xml.set("name", 'VitalityPoints')
|
|
17
|
954 self.sizer = wx.FlexGridSizer(2, 4, 2, 2) # rows, cols, hgap, vgap
|
|
28
|
955 self.xml = handler.xml
|
|
17
|
956 self.sizer.AddMany([ (wx.StaticText(self, -1, "VP Current:"), 0, wx.ALIGN_CENTER_VERTICAL),
|
|
28
|
957 (wx.TextCtrl(self, VP_CUR, self.xml.get('current')), 0, wx.EXPAND),
|
|
17
|
958 (wx.StaticText(self, -1, "VP Max:"), 0, wx.ALIGN_CENTER_VERTICAL),
|
|
28
|
959 (wx.TextCtrl(self, VP_MAX, self.xml.get('max')), 0, wx.EXPAND),
|
|
17
|
960 ])
|
|
|
961 self.sizer.AddGrowableCol(1)
|
|
|
962 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
963 self.Bind(wx.EVT_TEXT, self.on_text, id=VP_MAX)
|
|
|
964 self.Bind(wx.EVT_TEXT, self.on_text, id=VP_CUR)
|
|
|
965 self.SetSizer(self.sizer)
|
|
|
966
|
|
|
967 def on_text(self,evt):
|
|
|
968 id = evt.GetId()
|
|
28
|
969 if id == VP_CUR: self.xml.set('current',evt.GetString())
|
|
|
970 elif id == VP_MAX: self.xml.set('max',evt.GetString())
|
|
17
|
971
|
|
|
972 def on_size(self,evt):
|
|
|
973 s = self.GetClientSizeTuple()
|
|
|
974 self.sizer.SetDimension(0,0,s[0],s[1])
|
|
|
975
|
|
|
976
|
|
|
977 class gen_grid(wx.grid.Grid):
|
|
|
978 """grid for gen info"""
|
|
|
979 def __init__(self, parent, handler):
|
|
28
|
980 pname = handler.xml.set("name", 'General')
|
|
17
|
981 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
982 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
983 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
984 self.handler = handler
|
|
28
|
985 n_list = handler.xml.getchildren()
|
|
17
|
986 self.CreateGrid(len(n_list),2)
|
|
|
987 self.SetRowLabelSize(0)
|
|
|
988 self.SetColLabelSize(0)
|
|
|
989 self.n_list = n_list
|
|
|
990 i = 0
|
|
28
|
991 for i in range(len(n_list)): self.refresh_row(i)
|
|
17
|
992
|
|
|
993 def on_cell_change(self,evt):
|
|
|
994 row = evt.GetRow()
|
|
|
995 col = evt.GetCol()
|
|
|
996 value = self.GetCellValue(row,col)
|
|
28
|
997 self.n_list[row].text = value
|
|
17
|
998 if row==0: self.handler.on_name_change(value)
|
|
|
999
|
|
|
1000 def refresh_row(self,rowi):
|
|
28
|
1001 self.SetCellValue(rowi,0,self.n_list[rowi].tag)
|
|
17
|
1002 self.SetReadOnly(rowi,0)
|
|
28
|
1003 self.SetCellValue(rowi,1,self.n_list[rowi].text)
|
|
17
|
1004
|
|
|
1005 def on_size(self,evt):
|
|
|
1006 (w,h) = self.GetClientSizeTuple()
|
|
|
1007 cols = self.GetNumberCols()
|
|
|
1008 col_w = w/(cols)
|
|
28
|
1009 for i in range(0,cols): self.SetColSize(i,col_w)
|
|
17
|
1010 evt.Skip()
|
|
|
1011 self.Refresh()
|
|
|
1012
|
|
|
1013 class inventory_grid(wx.grid.Grid):
|
|
|
1014 """grid for gen info"""
|
|
|
1015 def __init__(self, parent, handler):
|
|
28
|
1016 pname = handler.xml.set("name", 'Money and Inventory')
|
|
17
|
1017 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1018 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1019 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1020 self.handler = handler
|
|
28
|
1021 n_list = handler.xml.getchildren()
|
|
17
|
1022 self.CreateGrid(len(n_list),2)
|
|
|
1023 self.SetRowLabelSize(0)
|
|
|
1024 self.SetColLabelSize(0)
|
|
|
1025 self.n_list = n_list
|
|
|
1026 i = 0
|
|
28
|
1027 for i in range(len(n_list)): self.refresh_row(i)
|
|
17
|
1028
|
|
|
1029 def on_cell_change(self,evt):
|
|
|
1030 row = evt.GetRow()
|
|
|
1031 col = evt.GetCol()
|
|
|
1032 value = self.GetCellValue(row,col)
|
|
28
|
1033 self.n_list[row].text = value
|
|
17
|
1034 if row==0: self.handler.on_name_change(value)
|
|
|
1035
|
|
|
1036 def refresh_row(self,rowi):
|
|
28
|
1037 self.SetCellValue(rowi,0, self.n_list[rowi].tag)
|
|
17
|
1038 self.SetReadOnly(rowi,0)
|
|
28
|
1039 self.SetCellValue(rowi,1,self.n_list[rowi].text)
|
|
17
|
1040
|
|
|
1041 def on_size(self,evt):
|
|
|
1042 (w,h) = self.GetClientSizeTuple()
|
|
|
1043 cols = self.GetNumberCols()
|
|
|
1044 col_w = w/(cols)
|
|
28
|
1045 for i in range(0,cols): self.SetColSize(i,col_w)
|
|
17
|
1046 evt.Skip()
|
|
|
1047 self.Refresh()
|
|
|
1048
|
|
|
1049 class abil_grid(wx.grid.Grid):
|
|
|
1050 """grid for abilities"""
|
|
|
1051 def __init__(self, parent, handler):
|
|
28
|
1052 pname = handler.xml.set("name", 'Stats')
|
|
17
|
1053 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1054 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1055 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1056 self.handler = handler
|
|
28
|
1057 stats = handler.xml.findall('stat')
|
|
17
|
1058 self.CreateGrid(len(stats),3)
|
|
|
1059 self.SetRowLabelSize(0)
|
|
|
1060 col_names = ['Ability','Score','Modifier']
|
|
28
|
1061 for i in range(len(col_names)): self.SetColLabelValue(i,col_names[i])
|
|
17
|
1062 self.stats = stats
|
|
|
1063 i = 0
|
|
28
|
1064 for i in range(len(stats)): self.refresh_row(i)
|
|
17
|
1065 self.char_wnd = None
|
|
|
1066
|
|
|
1067 def on_cell_change(self,evt):
|
|
|
1068 row = evt.GetRow()
|
|
|
1069 col = evt.GetCol()
|
|
|
1070 value = self.GetCellValue(row,col)
|
|
|
1071 try:
|
|
|
1072 int(value)
|
|
28
|
1073 self.stats[row].set('base',value)
|
|
17
|
1074 self.refresh_row(row)
|
|
28
|
1075 except: self.SetCellValue(row,col,"0")
|
|
|
1076 if self.char_wnd: self.char_wnd.refresh_data()
|
|
17
|
1077
|
|
|
1078 def refresh_row(self,rowi):
|
|
|
1079 s = self.stats[rowi]
|
|
28
|
1080 name = s.get('name')
|
|
|
1081 abbr = s.get('abbr')
|
|
17
|
1082 self.SetCellValue(rowi,0,name)
|
|
|
1083 self.SetReadOnly(rowi,0)
|
|
28
|
1084 self.SetCellValue(rowi,1,s.get('base'))
|
|
17
|
1085 self.SetCellValue(rowi,2,str(self.handler.get_mod(abbr)))
|
|
|
1086 self.SetReadOnly(rowi,2)
|
|
|
1087
|
|
|
1088 def on_size(self,evt):
|
|
|
1089 (w,h) = self.GetClientSizeTuple()
|
|
|
1090 cols = self.GetNumberCols()
|
|
|
1091 col_w = w/(cols+2)
|
|
|
1092 self.SetColSize(0,col_w*3)
|
|
28
|
1093 for i in range(1,cols): self.SetColSize(i,col_w)
|
|
17
|
1094 evt.Skip()
|
|
|
1095 self.Refresh()
|
|
|
1096
|
|
|
1097 def refresh_data(self):
|
|
28
|
1098 for r in range(self.GetNumberRows()-1): self.refresh_row(r)
|
|
17
|
1099
|
|
|
1100
|
|
|
1101 class save_grid(wx.grid.Grid):
|
|
|
1102 """grid for saves"""
|
|
|
1103 def __init__(self, parent, handler):
|
|
28
|
1104 pname = handler.xml.set("name", 'Saves')
|
|
17
|
1105 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1106 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1107 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1108 self.handler = handler
|
|
28
|
1109 saves = handler.xml.findall('save')
|
|
17
|
1110 self.stats = handler.char_hander.child_handlers['abilities']
|
|
|
1111 self.CreateGrid(len(saves),7)
|
|
|
1112 self.SetRowLabelSize(0)
|
|
|
1113 col_names = ['Save','Key','base','Abil','Magic','Misc','Total']
|
|
28
|
1114 for i in range(len(col_names)): self.SetColLabelValue(i,col_names[i])
|
|
17
|
1115 self.saves = saves
|
|
|
1116 i = 0
|
|
28
|
1117 for i in range(len(saves)):self.refresh_row(i)
|
|
17
|
1118
|
|
|
1119 def on_cell_change(self,evt):
|
|
|
1120 row = evt.GetRow()
|
|
|
1121 col = evt.GetCol()
|
|
|
1122 value = self.GetCellValue(row,col)
|
|
|
1123 try:
|
|
|
1124 int(value)
|
|
28
|
1125 if col == 2: self.saves[row].set('base',value)
|
|
|
1126 elif col == 4:self.saves[row].set('magmod',value)
|
|
|
1127 elif col == 4: self.saves[row].set('miscmod',value)
|
|
17
|
1128 self.refresh_row(row)
|
|
28
|
1129 except: self.SetCellValue(row,col,"0")
|
|
17
|
1130
|
|
|
1131 def refresh_row(self,rowi):
|
|
|
1132 s = self.saves[rowi]
|
|
28
|
1133 name = s.get('name')
|
|
17
|
1134 self.SetCellValue(rowi,0,name)
|
|
|
1135 self.SetReadOnly(rowi,0)
|
|
28
|
1136 stat = s.get('stat')
|
|
17
|
1137 self.SetCellValue(rowi,1,stat)
|
|
|
1138 self.SetReadOnly(rowi,1)
|
|
28
|
1139 self.SetCellValue(rowi,2,s.get('base'))
|
|
17
|
1140 self.SetCellValue(rowi,3,str(self.stats.get_mod(stat)))
|
|
|
1141 self.SetReadOnly(rowi,3)
|
|
28
|
1142 self.SetCellValue(rowi,4,s.get('magmod'))
|
|
|
1143 self.SetCellValue(rowi,5,s.get('miscmod'))
|
|
17
|
1144 mod = str(self.handler.get_mod(name))
|
|
|
1145 self.SetCellValue(rowi,6,mod)
|
|
|
1146 self.SetReadOnly(rowi,6)
|
|
|
1147
|
|
|
1148 def on_size(self,evt):
|
|
|
1149 (w,h) = self.GetClientSizeTuple()
|
|
|
1150 cols = self.GetNumberCols()
|
|
|
1151 col_w = w/(cols+2)
|
|
|
1152 self.SetColSize(0,col_w*3)
|
|
28
|
1153 for i in range(1,cols): self.SetColSize(i,col_w)
|
|
17
|
1154 evt.Skip()
|
|
|
1155 self.Refresh()
|
|
|
1156
|
|
|
1157 def refresh_data(self):
|
|
28
|
1158 for r in range(self.GetNumberRows()): self.refresh_row(r)
|
|
17
|
1159
|
|
|
1160
|
|
|
1161 class skill_grid(wx.grid.Grid):
|
|
|
1162 """ panel for skills """
|
|
|
1163 def __init__(self, parent, handler):
|
|
28
|
1164 pname = handler.xml.set("name", 'Skills')
|
|
17
|
1165 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1166 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1167 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1168 self.handler = handler
|
|
28
|
1169 skills = handler.xml.findall('skill')
|
|
17
|
1170 self.stats = handler.char_hander.child_handlers['abilities']
|
|
|
1171 self.CreateGrid(len(skills),7)
|
|
|
1172 self.SetRowLabelSize(0)
|
|
|
1173 col_names = ['Skill','Key','Rank','Abil','Misc','Total']
|
|
28
|
1174 for i in range(len(col_names)): self.SetColLabelValue(i,col_names[i])
|
|
17
|
1175 rowi = 0
|
|
|
1176 self.skills = skills
|
|
|
1177 for i in range(len(skills)):
|
|
|
1178 self.refresh_row(i)
|
|
|
1179
|
|
|
1180 def on_cell_change(self,evt):
|
|
|
1181 row = evt.GetRow()
|
|
|
1182 col = evt.GetCol()
|
|
|
1183 value = self.GetCellValue(row,col)
|
|
|
1184 #print value
|
|
|
1185 try:
|
|
|
1186 int(value)
|
|
28
|
1187 if col == 3: self.skills[row].set('rank',value)
|
|
|
1188 elif col == 5: self.skills[row].set('misc',value)
|
|
|
1189 elif col == 1: self.skills[row].set('untrained',value)
|
|
17
|
1190 self.refresh_row(row)
|
|
28
|
1191 except: self.SetCellValue(row,col,"0")
|
|
17
|
1192
|
|
|
1193 def refresh_row(self,rowi):
|
|
|
1194 s = self.skills[rowi]
|
|
28
|
1195 name = s.get('name')
|
|
17
|
1196 self.SetCellValue(rowi,0,name)
|
|
|
1197 self.SetReadOnly(rowi,0)
|
|
28
|
1198 self.SetCellValue(rowi,1,s.get('untrained'))
|
|
|
1199 stat = s.get('stat')
|
|
17
|
1200 self.SetCellValue(rowi,2,stat)
|
|
|
1201 self.SetReadOnly(rowi,2)
|
|
28
|
1202 self.SetCellValue(rowi,3,s.get('rank'))
|
|
17
|
1203 self.SetCellValue(rowi,4,str(self.stats.get_mod(stat)))
|
|
|
1204 self.SetReadOnly(rowi,4)
|
|
28
|
1205 self.SetCellValue(rowi,5,s.get('misc'))
|
|
17
|
1206 mod = str(self.handler.get_mod(name))
|
|
|
1207 self.SetCellValue(rowi,6,mod)
|
|
|
1208 self.SetReadOnly(rowi,6)
|
|
|
1209
|
|
|
1210 def on_size(self,evt):
|
|
|
1211 (w,h) = self.GetClientSizeTuple()
|
|
|
1212 cols = self.GetNumberCols()
|
|
|
1213 col_w = w/(cols+2)
|
|
|
1214 self.SetColSize(0,col_w*3)
|
|
28
|
1215 for i in range(1,cols): self.SetColSize(i,col_w)
|
|
17
|
1216 evt.Skip()
|
|
|
1217 self.Refresh()
|
|
|
1218
|
|
|
1219 def refresh_data(self):
|
|
28
|
1220 for r in range(self.GetNumberRows()): self.refresh_row(r)
|
|
17
|
1221
|
|
|
1222
|
|
|
1223 class feat_panel(wx.Panel):
|
|
|
1224 def __init__(self, parent, handler):
|
|
28
|
1225 pname = handler.xml.set("name", 'Feats')
|
|
17
|
1226 wx.Panel.__init__(self, parent, -1)
|
|
|
1227 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1228 sizer = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
1229 remove_btn = wx.Button(self, wx.ID_ANY, "Remove Feat")
|
|
|
1230 add_btn = wx.Button(self, wx.ID_ANY, "Add Feat")
|
|
|
1231 sizer.Add(remove_btn, 1, wx.EXPAND)
|
|
|
1232 sizer.Add(wx.Size(10,10))
|
|
|
1233 sizer.Add(add_btn, 1, wx.EXPAND)
|
|
|
1234 self.sizer = sizer
|
|
|
1235 self.SetSizer(self.sizer)
|
|
|
1236 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1237 self.Bind(wx.EVT_BUTTON, self.on_remove, remove_btn)
|
|
|
1238 self.Bind(wx.EVT_BUTTON, self.on_add, add_btn)
|
|
|
1239
|
|
28
|
1240 n_list = handler.xml.getchildren()
|
|
17
|
1241 self.n_list = n_list
|
|
28
|
1242 self.xml = handler.xml
|
|
17
|
1243 self.grid.CreateGrid(len(n_list),2,1)
|
|
|
1244 self.grid.SetRowLabelSize(0)
|
|
|
1245 self.grid.SetColLabelValue(0,"Feat")
|
|
|
1246 self.grid.SetColLabelValue(1,"Type")
|
|
28
|
1247 for i in range(len(n_list)): self.refresh_row(i)
|
|
17
|
1248 self.temp_dom = None
|
|
|
1249
|
|
|
1250 def refresh_row(self,i):
|
|
|
1251 feat = self.n_list[i]
|
|
28
|
1252 name = feat.get('name')
|
|
|
1253 type = feat.get('type')
|
|
17
|
1254 self.grid.SetCellValue(i,0,name)
|
|
|
1255 self.grid.SetReadOnly(i,0)
|
|
|
1256 self.grid.SetCellValue(i,1,type)
|
|
|
1257 self.grid.SetReadOnly(i,1)
|
|
|
1258
|
|
|
1259 def on_remove(self,evt):
|
|
|
1260 rows = self.grid.GetNumberRows()
|
|
|
1261 for i in range(rows):
|
|
|
1262 if self.grid.IsInSelection(i,0):
|
|
|
1263 self.grid.DeleteRows(i)
|
|
28
|
1264 self.xml.remove(self.n_list[i])
|
|
17
|
1265
|
|
|
1266 def on_add(self,evt):
|
|
|
1267 if not self.temp_dom:
|
|
28
|
1268 tree = parse(dir_struct["SWd20"]+"d20feats.xml")
|
|
|
1269 self.temp_dom = tree.getroot()
|
|
|
1270 f_list = self.temp_dom.findall('feat')
|
|
17
|
1271 opts = []
|
|
28
|
1272 for f in f_list: opts.append(f.get('name'))
|
|
17
|
1273 dlg = wx.SingleChoiceDialog(self,'Choose Feat','Feats',opts)
|
|
|
1274 if dlg.ShowModal() == wx.ID_OK:
|
|
|
1275 i = dlg.GetSelection()
|
|
28
|
1276 new_node = self.xml.append(f_list[i])
|
|
17
|
1277 self.grid.AppendRows(1)
|
|
|
1278 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
1279 dlg.Destroy()
|
|
|
1280
|
|
|
1281
|
|
|
1282 def on_size(self,event):
|
|
|
1283 s = self.GetClientSizeTuple()
|
|
|
1284 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
1285 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
1286 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
1287 cols = self.grid.GetNumberCols()
|
|
|
1288 col_w = w/(cols)
|
|
28
|
1289 for i in range(0,cols): self.grid.SetColSize(i,col_w)
|
|
17
|
1290
|
|
|
1291 class attack_grid(wx.grid.Grid):
|
|
|
1292 """grid for attacks"""
|
|
|
1293 def __init__(self, parent, handler):
|
|
28
|
1294 pname = handler.xml.set("name", 'Melee')
|
|
17
|
1295 wx.grid.Grid.__init__(self, parent, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1296 self.parent = parent
|
|
|
1297 self.handler = handler
|
|
|
1298 self.rows = (self.handler.melee,self.handler.ranged)
|
|
|
1299 self.CreateGrid(2,10)
|
|
|
1300 self.SetRowLabelSize(0)
|
|
|
1301 col_names = ['Type','base','base 2','base 3','base 4','base 5','base 6','abil','misc','Total']
|
|
28
|
1302 for i in range(len(col_names)): self.SetColLabelValue(i,col_names[i])
|
|
17
|
1303 self.SetCellValue(0,0,"Melee")
|
|
|
1304 self.SetCellValue(1,0,"Ranged")
|
|
|
1305 self.refresh_data()
|
|
|
1306 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1307 self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1308
|
|
|
1309 def on_cell_change(self,evt):
|
|
|
1310 row = evt.GetRow()
|
|
|
1311 col = evt.GetCol()
|
|
|
1312 value = self.GetCellValue(row,col)
|
|
|
1313 try:
|
|
|
1314 int(value)
|
|
28
|
1315 if col== 1: self.rows[row].set('base',value)
|
|
|
1316 elif col== 2: self.rows[row].set('second',value)
|
|
|
1317 elif col== 3: self.rows[row].set('third',value)
|
|
|
1318 elif col== 4: self.rows[row].set('forth',value)
|
|
|
1319 elif col== 5: self.rows[row].set('fifth',value)
|
|
|
1320 elif col== 6: self.rows[row].set('sixth',value)
|
|
|
1321 elif col== 8: self.rows[row].set('misc',value)
|
|
17
|
1322 self.parent.refresh_data()
|
|
28
|
1323 except: self.SetCellValue(row,col,"0")
|
|
17
|
1324
|
|
|
1325 def refresh_data(self):
|
|
|
1326 melee = self.handler.get_attack_data('m')
|
|
|
1327 ranged = self.handler.get_attack_data('r')
|
|
|
1328 for i in range(0,7):
|
|
|
1329 self.SetCellValue(0,i+1,str(melee[i]))
|
|
|
1330 self.SetCellValue(1,i+1,str(ranged[i]))
|
|
|
1331 self.SetCellValue(0,9,str(melee[0]+melee[6]+melee[7]))
|
|
|
1332 self.SetCellValue(1,9,str(ranged[0]+ranged[6]+ranged[7]))
|
|
|
1333 self.SetReadOnly(0,0)
|
|
|
1334 self.SetReadOnly(1,0)
|
|
|
1335 self.SetReadOnly(0,7)
|
|
|
1336 self.SetReadOnly(1,7)
|
|
|
1337 self.SetReadOnly(0,9)
|
|
|
1338 self.SetReadOnly(1,9)
|
|
|
1339
|
|
|
1340 def on_size(self,evt):
|
|
|
1341 (w,h) = self.GetClientSizeTuple()
|
|
|
1342 cols = self.GetNumberCols()
|
|
|
1343 col_w = w/(cols+1)
|
|
|
1344 self.SetColSize(0,col_w*2)
|
|
28
|
1345 for i in range(1,cols): self.SetColSize(i,col_w)
|
|
17
|
1346 evt.Skip()
|
|
|
1347 self.Refresh()
|
|
|
1348
|
|
|
1349 class weapon_panel(wx.Panel):
|
|
|
1350 def __init__(self, parent, handler):
|
|
28
|
1351 pname = handler.xml.set("name", 'Weapons')
|
|
17
|
1352 wx.Panel.__init__(self, parent, -1)
|
|
|
1353 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1354 sizer = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
1355 remove_btn = wx.Button(self, 10, "Remove Weapon")
|
|
|
1356 add_btn = wx.Button(self, 20, "Add Weapon")
|
|
|
1357 sizer.Add(remove_btn, 1, wx.EXPAND)
|
|
|
1358 sizer.Add(wx.Size(10,10))
|
|
|
1359 sizer.Add(add_btn, 1, wx.EXPAND)
|
|
|
1360 self.sizer = sizer
|
|
|
1361 self.SetSizer(self.sizer)
|
|
|
1362 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1363 self.Bind(wx.EVT_BUTTON, self.on_remove, remove_btn)
|
|
|
1364 self.Bind(wx.EVT_BUTTON, self.on_add, add_btn)
|
|
|
1365 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
28
|
1366 n_list = handler.xml.findall('weapon')
|
|
17
|
1367 self.n_list = n_list
|
|
28
|
1368 self.xml = handler.xml
|
|
17
|
1369 self.handler = handler
|
|
|
1370 self.grid.CreateGrid(len(n_list),9,1)
|
|
|
1371 self.grid.SetRowLabelSize(0)
|
|
|
1372 col_names = ['Name','damage','mod','critical','type','weight','range','size','Total']
|
|
28
|
1373 for i in range(len(col_names)): self.grid.SetColLabelValue(i,col_names[i])
|
|
17
|
1374 self.refresh_data()
|
|
|
1375 self.temp_dom = None
|
|
|
1376
|
|
|
1377 def on_cell_change(self,evt):
|
|
|
1378 row = evt.GetRow()
|
|
|
1379 col = evt.GetCol()
|
|
|
1380 value = self.grid.GetCellValue(row,col)
|
|
28
|
1381 if col == 0: self.n_list[row].set('name',value)
|
|
17
|
1382 elif col == 2:
|
|
|
1383 try:
|
|
|
1384 int(value)
|
|
28
|
1385 self.n_list[row].set('mod',value)
|
|
17
|
1386 self.refresh_row(row)
|
|
28
|
1387 except: self.grid.SetCellValue(row,col,"1")
|
|
|
1388 else: self.n_list[row].set(self.grid.GetColLabelValue(col),value)
|
|
17
|
1389
|
|
|
1390 def refresh_row(self,i):
|
|
|
1391 n = self.n_list[i]
|
|
28
|
1392 name = n.get('name')
|
|
|
1393 mod = n.get('mod')
|
|
|
1394 ran = n.get('range')
|
|
17
|
1395 total = str(int(mod) + self.handler.get_mod(ran))
|
|
|
1396 self.grid.SetCellValue(i,0,name)
|
|
28
|
1397 self.grid.SetCellValue(i,1,n.get('damage'))
|
|
17
|
1398 self.grid.SetCellValue(i,2,mod)
|
|
28
|
1399 self.grid.SetCellValue(i,3,n.get('critical'))
|
|
|
1400 self.grid.SetCellValue(i,4,n.get('type'))
|
|
|
1401 self.grid.SetCellValue(i,5,n.get('weight'))
|
|
17
|
1402 self.grid.SetCellValue(i,6,ran)
|
|
28
|
1403 self.grid.SetCellValue(i,7,n.get('size') )
|
|
17
|
1404 self.grid.SetCellValue(i,8,total)
|
|
|
1405 self.grid.SetReadOnly(i,8)
|
|
|
1406
|
|
|
1407 def on_remove(self,evt):
|
|
|
1408 rows = self.grid.GetNumberRows()
|
|
|
1409 for i in range(rows):
|
|
|
1410 if self.grid.IsInSelection(i,0):
|
|
|
1411 self.grid.DeleteRows(i)
|
|
28
|
1412 self.xml.remove(self.n_list[i])
|
|
|
1413 self.n_list = self.xml.findall('weapon')
|
|
17
|
1414 self.handler.refresh_weapons()
|
|
|
1415
|
|
|
1416 def on_add(self,evt):
|
|
|
1417 if not self.temp_dom:
|
|
28
|
1418 tree = parse(dir_struct["SWd20"]+"d20weapons.xml")
|
|
|
1419 self.temp_dom = tree.getroot()
|
|
|
1420 f_list = self.temp_dom.findall('weapon')
|
|
17
|
1421 opts = []
|
|
|
1422 for f in f_list:
|
|
28
|
1423 opts.append(f.get('name'))
|
|
17
|
1424 dlg = wx.SingleChoiceDialog(self,'Choose Weapon','Weapon List',opts)
|
|
|
1425 if dlg.ShowModal() == wx.ID_OK:
|
|
|
1426 i = dlg.GetSelection()
|
|
28
|
1427 new_node = self.xml.append(f_list[i])
|
|
17
|
1428 self.grid.AppendRows(1)
|
|
28
|
1429 self.n_list = self.xml.findall('weapon')
|
|
17
|
1430 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
1431 self.handler.refresh_weapons()
|
|
|
1432 dlg.Destroy()
|
|
|
1433
|
|
|
1434 def on_size(self,event):
|
|
|
1435 s = self.GetClientSizeTuple()
|
|
|
1436 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
1437 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
1438 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
1439 cols = self.grid.GetNumberCols()
|
|
|
1440 col_w = w/(cols+1)
|
|
|
1441 self.grid.SetColSize(0,col_w*2)
|
|
28
|
1442 for i in range(1,cols): self.grid.SetColSize(i,col_w)
|
|
17
|
1443
|
|
|
1444 def refresh_data(self):
|
|
28
|
1445 for i in range(len(self.n_list)): self.refresh_row(i)
|
|
17
|
1446
|
|
|
1447
|
|
|
1448 class attack_panel(wx.Panel):
|
|
|
1449 def __init__(self, parent, handler):
|
|
28
|
1450 pname = handler.xml.set("name", 'Melee')
|
|
17
|
1451 wx.Panel.__init__(self, parent, -1)
|
|
|
1452 self.a_grid = attack_grid(self, handler)
|
|
|
1453 self.w_panel = weapon_panel(self, handler)
|
|
|
1454 self.sizer = wx.BoxSizer(wx.VERTICAL)
|
|
|
1455 self.sizer.Add(self.a_grid, 1, wx.EXPAND)
|
|
|
1456 self.sizer.Add(self.w_panel, 2, wx.EXPAND)
|
|
|
1457 self.SetSizer(self.sizer)
|
|
|
1458 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1459
|
|
|
1460 def on_size(self,event):
|
|
|
1461 s = self.GetClientSizeTuple()
|
|
|
1462 self.sizer.SetDimension(0,0,s[0],s[1])
|
|
|
1463
|
|
|
1464 def refresh_data(self):
|
|
|
1465 self.w_panel.refresh_data()
|
|
|
1466 self.a_grid.refresh_data()
|
|
|
1467
|
|
|
1468
|
|
|
1469 class ac_panel(wx.Panel):
|
|
|
1470 def __init__(self, parent, handler):
|
|
28
|
1471 pname = handler.xml.set("name", 'Armor')
|
|
17
|
1472 wx.Panel.__init__(self, parent, -1)
|
|
|
1473 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1474 sizer = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
1475 remove_btn = wx.Button(self, 10, "Remove Armor")
|
|
|
1476 add_btn = wx.Button(self, 20, "Add Armor")
|
|
|
1477 sizer.Add(remove_btn, 1, wx.EXPAND)
|
|
|
1478 sizer.Add(wx.Size(10,10))
|
|
|
1479 sizer.Add(add_btn, 1, wx.EXPAND)
|
|
|
1480 self.sizer = sizer
|
|
|
1481 self.SetSizer(self.sizer)
|
|
|
1482 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1483 self.Bind(wx.EVT_BUTTON, self.on_remove, remove_btn)
|
|
|
1484 self.Bind(wx.EVT_BUTTON, self.on_add, add_btn)
|
|
|
1485 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
28
|
1486 self.xml = handler.xml
|
|
|
1487 n_list = handler.xml.getchildren()
|
|
17
|
1488 self.n_list = n_list
|
|
|
1489 col_names = ['Armor','DR','Max Dex','Check Penalty','Weight','Speed (10)','Speed (6)','type']
|
|
|
1490 self.grid.CreateGrid(len(n_list),len(col_names),1)
|
|
|
1491 self.grid.SetRowLabelSize(0)
|
|
28
|
1492 for i in range(len(col_names)): self.grid.SetColLabelValue(i,col_names[i])
|
|
17
|
1493 self.atts =['name','bonus','maxdex','checkpenalty','weight','speed','speed6','type']
|
|
28
|
1494 for i in range(len(n_list)): self.refresh_row(i)
|
|
17
|
1495 self.temp_dom = None
|
|
|
1496
|
|
|
1497
|
|
|
1498 def on_cell_change(self,evt):
|
|
|
1499 row = evt.GetRow()
|
|
|
1500 col = evt.GetCol()
|
|
|
1501 value = self.grid.GetCellValue(row,col)
|
|
|
1502 if col >= 1 and col <= 5:
|
|
|
1503 try:
|
|
|
1504 int(value)
|
|
28
|
1505 self.n_list[row].set(self.atts[col],value)
|
|
|
1506 except: self.grid.SetCellValue(row,col,"0")
|
|
|
1507 else: self.n_list[row].set(self.atts[col],value)
|
|
17
|
1508
|
|
|
1509 def refresh_row(self,i):
|
|
|
1510 n = self.n_list[i]
|
|
28
|
1511 for y in range(len(self.atts)): self.grid.SetCellValue(i,y,n.get(self.atts[y]))
|
|
17
|
1512
|
|
|
1513 def on_remove(self,evt):
|
|
|
1514 rows = self.grid.GetNumberRows()
|
|
|
1515 for i in range(rows):
|
|
|
1516 if self.grid.IsInSelection(i,0):
|
|
|
1517 self.grid.DeleteRows(i)
|
|
28
|
1518 self.xml.remove(self.n_list[i])
|
|
17
|
1519
|
|
|
1520 def on_add(self,evt):
|
|
|
1521 if not self.temp_dom:
|
|
28
|
1522 tree = parse(dir_struct["SWd20"]+"d20armor.xml")
|
|
|
1523 self.temp_dom = tree.getroot()
|
|
|
1524 f_list = self.temp_dom.findall('armor')
|
|
17
|
1525 opts = []
|
|
28
|
1526 for f in f_list: opts.append(f.get('name'))
|
|
17
|
1527 dlg = wx.SingleChoiceDialog(self,'Choose Armor:','Armor List',opts)
|
|
|
1528 if dlg.ShowModal() == wx.ID_OK:
|
|
|
1529 i = dlg.GetSelection()
|
|
28
|
1530 new_node = self.xml.append(f_list[i])
|
|
17
|
1531 self.grid.AppendRows(1)
|
|
|
1532 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
1533 dlg.Destroy()
|
|
|
1534
|
|
|
1535 def on_size(self,event):
|
|
|
1536 s = self.GetClientSizeTuple()
|
|
|
1537 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
1538 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
1539 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
1540 cols = self.grid.GetNumberCols()
|
|
|
1541 col_w = w/(cols+2)
|
|
|
1542 self.grid.SetColSize(0,col_w*3)
|
|
28
|
1543 for i in range(1,cols): self.grid.SetColSize(i,col_w)
|
|
17
|
1544
|
|
|
1545
|
|
|
1546 class class_panel(wx.Panel):
|
|
|
1547 def __init__(self, parent, handler):
|
|
28
|
1548 pname = handler.xml.set("name", 'Class')
|
|
17
|
1549 wx.Panel.__init__(self, parent, -1)
|
|
|
1550 self.grid =wx.grid.Grid(self, -1, style=wx.SUNKEN_BORDER | wx.WANTS_CHARS)
|
|
|
1551 sizer = wx.BoxSizer(wx.HORIZONTAL)
|
|
|
1552 remove_btn = wx.Button(self, wx.ID_ANY, "Remove Class")
|
|
|
1553 add_btn = wx.Button(self, wx.ID_ANY, "Add Class")
|
|
|
1554 sizer.Add(remove_btn, 1, wx.EXPAND)
|
|
|
1555 sizer.Add(wx.Size(10,10))
|
|
|
1556 sizer.Add(add_btn, 1, wx.EXPAND)
|
|
|
1557 self.sizer = sizer
|
|
|
1558 self.SetSizer(self.sizer)
|
|
|
1559 self.Bind(wx.EVT_SIZE, self.on_size)
|
|
|
1560 self.Bind(wx.EVT_BUTTON, self.on_remove, remove_btn)
|
|
|
1561 self.Bind(wx.EVT_BUTTON, self.on_add, add_btn)
|
|
|
1562 self.grid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.on_cell_change)
|
|
|
1563
|
|
28
|
1564 n_list = handler.xml.getchildren()
|
|
17
|
1565 self.n_list = n_list
|
|
28
|
1566 self.xml = handler.xml
|
|
17
|
1567 self.grid.CreateGrid(len(n_list),2,1)
|
|
|
1568 self.grid.SetRowLabelSize(0)
|
|
|
1569 self.grid.SetColLabelValue(0,"Class")
|
|
|
1570 self.grid.SetColLabelValue(1,"Level")
|
|
28
|
1571 for i in range(len(n_list)): self.refresh_row(i)
|
|
17
|
1572 self.temp_dom = None
|
|
|
1573
|
|
|
1574 def on_cell_change(self,evt):
|
|
|
1575 row = evt.GetRow()
|
|
|
1576 col = evt.GetCol()
|
|
|
1577 value = self.grid.GetCellValue(row,col)
|
|
|
1578 try:
|
|
|
1579 int(value)
|
|
28
|
1580 self.n_list[row].set('level',value)
|
|
|
1581 except: self.grid.SetCellValue(row,col,"1")
|
|
17
|
1582
|
|
|
1583
|
|
|
1584 def refresh_row(self,i):
|
|
|
1585 n = self.n_list[i]
|
|
28
|
1586 name = n.get('name')
|
|
|
1587 level = n.get('level')
|
|
17
|
1588 self.grid.SetCellValue(i,0,name)
|
|
|
1589 self.grid.SetReadOnly(i,0)
|
|
|
1590 self.grid.SetCellValue(i,1,level)
|
|
|
1591
|
|
|
1592 def on_remove(self,evt):
|
|
|
1593 rows = self.grid.GetNumberRows()
|
|
|
1594 for i in range(rows):
|
|
|
1595 if self.grid.IsInSelection(i,0):
|
|
|
1596 self.grid.DeleteRows(i)
|
|
28
|
1597 self.xml.remove(self.n_list[i])
|
|
17
|
1598
|
|
|
1599 def on_add(self,evt):
|
|
|
1600 if not self.temp_dom:
|
|
28
|
1601 tree = parse(dir_struct["SWd20"]+"SWd20classes.xml")
|
|
|
1602 self.temp_dom = tree.getroot()
|
|
|
1603 f_list = self.temp_dom.findall('class')
|
|
17
|
1604 opts = []
|
|
28
|
1605 for f in f_list: opts.append(f.get('name'))
|
|
17
|
1606 dlg = wx.SingleChoiceDialog(self,'Choose Class','Classes',opts)
|
|
|
1607 if dlg.ShowModal() == wx.ID_OK:
|
|
|
1608 i = dlg.GetSelection()
|
|
28
|
1609 new_node = self.xml.append(f_list[i])
|
|
17
|
1610 self.grid.AppendRows(1)
|
|
|
1611 self.refresh_row(self.grid.GetNumberRows()-1)
|
|
|
1612 dlg.Destroy()
|
|
|
1613
|
|
|
1614
|
|
|
1615 def on_size(self,event):
|
|
|
1616 s = self.GetClientSizeTuple()
|
|
|
1617 self.grid.SetDimensions(0,0,s[0],s[1]-25)
|
|
|
1618 self.sizer.SetDimension(0,s[1]-25,s[0],25)
|
|
|
1619 (w,h) = self.grid.GetClientSizeTuple()
|
|
|
1620 cols = self.grid.GetNumberCols()
|
|
|
1621 col_w = w/(cols)
|
|
28
|
1622 for i in range(0,cols): self.grid.SetColSize(i,col_w)
|
|
|
1623
|
