spacepaste

Paste details

reply | raw

  1.  
  2. import warnings
  4. from types import ClassType
  5. from pandac.PandaModules import *
  7. from zc.units.baseunit import BaseUnit, strict_callback, higher_callback, loose_callback
  8. from zc.ai.empty import EmptyAi
  9. from zc.ai.pathfinder import STATE_QUEUED, STATE_FOUND, STATE_NOT_FOUND
  10. from zc.shaders import shader_manipulator
  13. NODE_MOVE_SPEED = 0.5/16
  14. # Unitstats
  16. VIEW_RADIUS = 320
  19. class ZombieFemale(BaseUnit):
  20. """
  21. Basic zombie, female variant
  23. basic unit controller without any ai to govern it
  24. will move and do stuff according to the orders depending on the issuer and type of callback
  25. (strict, higher, loose)
  27. Accepts events:
  29. on_unit_move_order_issued
  30. parameters: issuer, target, wherex, wherey
  32. on_unit_teleport_order_issued
  33. parameters: issuer, target
  35. on_unit_stop_order_issued
  36. parameters: issuer, target
  38. Sends events:
  40. on_unit_moved
  41. Sends: self
  43. on_unit_teleported
  44. Sends: self
  46. on_unit_stopped
  47. Sends: self
  49. """
  50. Models = [
  51. "models/mod.egg",
  52. ]
  53. Textures = [
  54. "textures/text.png",
  55. ]
  56. Animations = {
  57. "idle":("idle01", "idle02"),
  58. "walking-slow":("walkslow01",),
  59. }
  61. def __init__(self, game, renderer, x, y, controller, Ai=None, name=None):
  62. BaseUnit.__init__(self, game, renderer, x, y, controller, Ai, name)
  63. # consts
  65. self.VIEW_RADIUS = VIEW_RADIUS
  68. # semaphors
  69. self._moving = False
  71. self._behaviour = "zombie"
  72. self._type = "zombie_female"
  74. self._actor = False
  76. while self._actor is False:
  77. self._model = self._game.game_values["static_random"].choice(ZombieFemale.Models)
  78. self._texture = self._game._map.f(self._game.game_values["static_random"].choice(ZombieFemale.Textures), "t")
  80. self._actor = None
  81. self._siz = 6.0
  83. self._actor = shader_manipulator.new_instance_with_shaders(self,
  84. self._game._map.f,
  85. self._name,
  86. self._model,
  87. self._game.game_values["static_random"].choice(ZombieFemale.Animations["idle"]),
  88. self._texture,
  89. self._siz)
  92. self.update(all=True)
  93. # base behaviour event registration:
  94. self.regEv("on_unit_move_order_issued", self._move)
  95. self.regEv("on_unit_teleport_order_issued", self._teleport)
  99. @strict_callback
  100. def _move(self, event, issuer, target, wherex, wherey):
  101. if (wherex == self._posx) and (wherey == self._posy):
  102. return True
  103. if self._moving:
  104. self.unschedEv(self._move_unit)
  108. fpath = self._game._pathfinder.find_path(self._move_callback,
  109. (int(self._posx / 16), int(self._posy / 16)),
  110. (int(wherex / 16), int(wherey / 16)),
  111. True
  112. )
  114. fpath._store_x = wherex
  115. fpath._store_y = wherey
  118. if fpath.get_state() != STATE_QUEUED:
  119. if fpath.get_state() == STATE_NOT_FOUND:
  120. self._stop(event, issuer, target)
  121. return True
  122. else:
  123. self._move_command(fpath)
  124. return True
  125. else:
  126. # TODO: Nastavit zombie na dumanie...
  127. return True
  130. def _move_callback(self, fpath, *args):
  131. if fpath.get_state() == STATE_FOUND:
  132. self._move_command(fpath)
  133. else:
  134. self._stop(None, None, None)
  137. def _move_command(self, fpath, wtype="walking-slow"):
  139. self.trigEv("on_unit_move", self)
  141. anim = self._game.game_values["game_random"].choice(ZombieFemale.Animations[wtype])
  142. self.update_anim(anim)
  144. class CT(object):
  145. def __init__(inself):
  146. inself.x = None
  147. inself.y = None
  148. inself.w = None
  150. inself.targetx = fpath._store_x
  151. inself.targety = fpath._store_y
  153. inself.final = False
  155. current_target = CT()
  156. target_list = iter(fpath.get_path())
  158. cnode = target_list.next()
  160. current_target.x, current_target.y = cnode.get_position()
  161. current_target.w = cnode.get_weight()
  163. # TODO: Pridat pametanie si weight... alebo nieco podobne...
  164. delay = 0
  165. if current_target.w > 0:
  166. delay = NODE_MOVE_SPEED * ((1/256.0) * (256-current_target.w))
  167. elif current_target.w < 0:
  168. delay = NODE_MOVE_SPEED / ((1/256.0) * (256-current_target.w))
  169. else:
  170. delay = NODE_MOVE_SPEED
  172. self._angle = [None, None]
  174. self._moving = True # we set up semaphore
  175. self.schedEv(self._move_unit, d=delay, p_kwargs={"current_target":current_target, "target_list":target_list})
  178. def _move_unit(self, dt, current_target, target_list):
  179. cposx = int(self._posx)
  180. cposy = int(self._posy)
  182. if current_target.final:
  183. if (cposx == current_target.targetx) and (cposy == current_target.targety):
  184. # we have arrived at final node!
  185. self._angle = [None, None]
  186. self._stop(None, self._name, None)
  187. # we clear semaphore
  188. self._moving = False
  189. return True
  191. modx, mody, orient = self._get_next_position(cposx, cposy, current_target.targetx, current_target.y)
  193. self._posx = modx
  194. self._posy = mody
  195. self._orient = orient
  197. self.update()
  198. return
  200. if (cposx == current_target.x*16) and (cposy == current_target.y*16):
  201. # we have arrived at the node
  202. self._ai.arrived_at_new_position()
  203. cnode = None
  204. try:
  205. cnode = target_list.next() # we set up new target coordinates
  206. except StopIteration:
  207. current_target.final = True
  208. return
  209. else:
  210. current_target.x, current_target.y = cnode.get_position()
  211. w = cnode.get_weight()
  213. if w != current_target.w:
  214. # TODO: Vylepsit, ale asi tazko, leda animacne!
  215. delay = 0
  216. d = (w + current_target.w) / 2
  217. if d > 0:
  218. delay = NODE_MOVE_SPEED * ((1/256.0) * (256-d))
  219. elif d < 0:
  220. delay = NODE_MOVE_SPEED / ((1/256.0) * (256-d))
  221. else:
  222. delay = NODE_MOVE_SPEED
  224. self._angle = [None, None]
  225. current_target.w = w
  227. self.unschedEv(self._move_unit)
  228. self.schedEv(self._move_unit, d=delay, p_kwargs={"current_target":current_target, "target_list":target_list})
  230. self._angle = [None, None]
  233. modx, mody, orient = self._get_next_position(cposx, cposy, current_target.x*16, current_target.y*16)
  235. self._posx = modx
  236. self._posy = mody
  239. self._orient = orient
  241. self.update()
  244. @strict_callback
  245. def _teleport(self, event, issuer, target, wherex, wherey):
  246. self._actor.setPos(wherex, wherey, self._getheight(wherex, wherey))
  247. self._posx = wherex
  248. self._posy = wherey
  250. self.trigEv("on_unit_teleport", self)
  251. self._ai.arrived_at_new_position()
  254. self._stop(event, issuer, target)
  257. @loose_callback
  258. def _stop(self, event, issuer, target):
  260. self.trigEv("on_unit_stop", self)
  262. anim = self._game.game_values["game_random"].choice(ZombieFemale.Animations["idle"])
  263. self.update_anim(anim)
  264. self.unschedEv("all") # unscheduling any events pending
  265. # we clear semaphores
  266. self._moving = False
  271.  
Powered by spacepaste. Paste removal.