mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 21:27:52 -04:00
626 lines
22 KiB
Common Lisp
626 lines
22 KiB
Common Lisp
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
#|
|
|
|
|
Code for extra HUD elements in the PC port.
|
|
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;; constants
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
(defconstant HUD_ICON_COUNT 6)
|
|
(defconstant HUD_PART_PC_AMOUNT 1)
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;; hud processes and parts
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;; a pc hud element
|
|
(deftype hud-pc (hud)
|
|
()
|
|
)
|
|
|
|
;; hud element for battles
|
|
(deftype hud-battle-enemy (hud)
|
|
((want-skel symbol)
|
|
(want-skel2 symbol)
|
|
|
|
(last-battle handle)
|
|
(battle-entity entity-actor)
|
|
(battle-max int32)
|
|
(battle-alive int32)
|
|
(battle-mode symbol)
|
|
(last-task entity-actor)
|
|
(task-entity entity-actor)
|
|
(task-track int32)
|
|
(task2-entity entity-actor)
|
|
(task2-time time-frame)
|
|
(task2-track int32)
|
|
|
|
(last-level symbol)
|
|
(ready? symbol)
|
|
(kicked symbol)
|
|
(display-mode? symbol)
|
|
)
|
|
(:methods
|
|
(make-enemy-icon (_type_ int symbol entity) int)
|
|
(kill-icon (_type_ int) int)
|
|
(kill-all-icons (_type_) int)
|
|
(update-display-status (_type_ symbol entity int symbol) int)
|
|
)
|
|
)
|
|
|
|
|
|
;; all pc hud elements
|
|
(deftype hud-parts-pc (structure)
|
|
((battle-enemy (pointer hud-battle-enemy))
|
|
|
|
(parts (pointer hud-pc) HUD_PART_PC_AMOUNT :offset 0)
|
|
)
|
|
)
|
|
|
|
|
|
|
|
;;;----------------------------------------------
|
|
;; globals
|
|
;;;----------------------------------------------
|
|
|
|
|
|
;; all of the pc hud elements
|
|
(define *hud-parts-pc* (new 'static 'hud-parts-pc
|
|
:battle-enemy #f
|
|
))
|
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;; hud macros
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
(defmacro hud-pc-make-icon (obj max &key skel
|
|
&key x
|
|
&key y
|
|
&key z
|
|
&key scale-x
|
|
&key scale-y
|
|
&key (entity #f)
|
|
)
|
|
`(when (< (-> ,obj nb-of-icons) ,max)
|
|
(let ((icon-idx (-> ,obj nb-of-icons)))
|
|
(set! (-> ,obj icons icon-idx) (new 'static 'hud-icon))
|
|
(let ((new-manipy (manipy-spawn (new 'static 'vector :w 1.0) ,entity ,skel #f :to ,obj)))
|
|
(when new-manipy
|
|
(set! (-> (-> new-manipy) draw dma-add-func) dma-add-process-drawable-hud-with-hud-lights)
|
|
(set-vector! (-> (-> new-manipy) root trans) 0.0 0.0 0.0 1.0)
|
|
(set-vector! (-> (-> new-manipy) root scale) ,scale-x ,scale-y ,scale-x 1.0)
|
|
(when #f
|
|
(send-event (ppointer->process new-manipy) 'trans-hook #f)
|
|
)
|
|
)
|
|
(set! (-> ,obj icons icon-idx icon) new-manipy)
|
|
(when new-manipy
|
|
(logior! (-> new-manipy 0 mask) (process-mask pause))
|
|
(logclear! (-> new-manipy 0 mask) (process-mask menu progress))
|
|
(set! (-> (-> new-manipy) root trans z) ,z)
|
|
(set! (-> ,obj icons icon-idx icon-x) ,x)
|
|
(set! (-> ,obj icons icon-idx icon-y) ,y)
|
|
(set! (-> ,obj icons icon-idx icon-z) 0)
|
|
(set! (-> ,obj icons icon-idx scale-x) ,scale-x)
|
|
(set! (-> ,obj icons icon-idx scale-y) ,scale-y)
|
|
)
|
|
)
|
|
)
|
|
(+! (-> ,obj nb-of-icons) 1)
|
|
)
|
|
)
|
|
|
|
(defmacro hud-pc-replace-icon (obj idx &key skel
|
|
&key z
|
|
&key (entity #f)
|
|
)
|
|
`(let ((new-manipy (manipy-spawn (new 'static 'vector :w 1.0) ,entity ,skel #f :to ,obj)))
|
|
(when new-manipy
|
|
(set! (-> (-> new-manipy) draw dma-add-func) dma-add-process-drawable-hud-with-hud-lights)
|
|
(set-vector! (-> (-> new-manipy) root trans) 0.0 0.0 0.0 1.0)
|
|
(set-vector! (-> (-> new-manipy) root scale) (-> ,obj icons ,idx scale-x) (-> ,obj icons ,idx scale-y) (-> ,obj icons ,idx scale-x) 1.0)
|
|
(when #f
|
|
(send-event (ppointer->process new-manipy) 'trans-hook #f)
|
|
)
|
|
)
|
|
(set! (-> ,obj icons ,idx icon) new-manipy)
|
|
(when new-manipy
|
|
(logior! (-> new-manipy 0 mask) (process-mask pause))
|
|
(logclear! (-> new-manipy 0 mask) (process-mask menu progress))
|
|
(set! (-> (-> new-manipy) root trans z) ,z)
|
|
)
|
|
)
|
|
)
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;; hud rendering with level lights
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
(define *hud-pc-lights* (new 'global 'vu-lights))
|
|
(set-vector! (-> *hud-pc-lights* direction 0) 1.0 0.0 0.0 1.0)
|
|
(set-vector! (-> *hud-pc-lights* direction 1) 0.0 1.0 0.0 1.0)
|
|
(set-vector! (-> *hud-pc-lights* direction 2) 0.0 0.0 1.0 1.0)
|
|
(set-vector! (-> *hud-pc-lights* color 0) 0.75 0.75 1.0 1.0)
|
|
(set-vector! (-> *hud-pc-lights* color 1) 0.75 0.75 1.0 1.0)
|
|
(set-vector! (-> *hud-pc-lights* color 2) 0.75 0.75 1.0 1.0)
|
|
(set-vector! (-> *hud-pc-lights* ambient) 0.2 0.2 0.2 1.0)
|
|
|
|
(defun dma-add-process-drawable-hud-with-lights ((proc process-drawable) (draw draw-control) (arg2 symbol) (buf dma-buffer))
|
|
(logclear! (-> draw status) (draw-status was-drawn))
|
|
(when (zero? (logand (-> draw status) (draw-status hidden no-anim no-skeleton-update)))
|
|
(let ((vu-lgt (the-as vu-lights (+ 64 (scratchpad-object int))))
|
|
(lgt (if (= (-> draw level-index) 2)
|
|
(-> *time-of-day-context* light-group (-> draw light-index))
|
|
(-> *time-of-day-context* moods (-> draw level-index) light-group (-> draw light-index))
|
|
))
|
|
)
|
|
(vu-lights<-light-group! vu-lgt lgt)
|
|
)
|
|
(lod-set! draw 0)
|
|
(logior! (-> draw status) (draw-status was-drawn))
|
|
(draw-bones-hud draw buf)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defun dma-add-process-drawable-hud-with-hud-lights ((proc process-drawable) (draw draw-control) (arg2 symbol) (buf dma-buffer))
|
|
(logclear! (-> draw status) (draw-status was-drawn))
|
|
(when (zero? (logand (-> draw status) (draw-status hidden no-anim no-skeleton-update)))
|
|
(let ((vu-lgt (the-as vu-lights (+ 64 (scratchpad-object int))))
|
|
(lgt *hud-pc-lights*)
|
|
)
|
|
(set! (-> vu-lgt direction 0 quad) (-> lgt direction 0 quad))
|
|
(set! (-> vu-lgt direction 1 quad) (-> lgt direction 1 quad))
|
|
(set! (-> vu-lgt direction 2 quad) (-> lgt direction 2 quad))
|
|
(set! (-> vu-lgt color 0 quad) (-> lgt color 0 quad))
|
|
(set! (-> vu-lgt color 1 quad) (-> lgt color 1 quad))
|
|
(set! (-> vu-lgt color 2 quad) (-> lgt color 2 quad))
|
|
(set! (-> vu-lgt ambient quad) (-> lgt ambient quad))
|
|
)
|
|
(lod-set! draw 0)
|
|
(logior! (-> draw status) (draw-status was-drawn))
|
|
(draw-bones-hud draw buf)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;; hud methods
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
|
|
(defmethod deactivate hud-pc ((obj hud-pc))
|
|
(dotimes (i HUD_PART_PC_AMOUNT)
|
|
(if (and (-> *hud-parts-pc* parts i) (= (ppointer->process (-> *hud-parts-pc* parts i)) obj))
|
|
(set! (-> *hud-parts-pc* parts i) (the (pointer hud-pc) #f))
|
|
)
|
|
)
|
|
((method-of-type hud deactivate) obj)
|
|
(none)
|
|
)
|
|
|
|
|
|
(defmethod kill-icon hud-battle-enemy ((obj hud-battle-enemy) (idx int))
|
|
"kill a hud icon"
|
|
|
|
(when (and (nonzero? (-> obj icons idx)) (nonzero? (-> obj icons idx icon)) (-> obj icons idx icon))
|
|
(deactivate (ppointer->process (-> obj icons idx icon)))
|
|
(set! (-> obj icons idx icon) #f)
|
|
)
|
|
0)
|
|
|
|
(defmethod kill-all-icons hud-battle-enemy ((obj hud-battle-enemy))
|
|
"kill all hud icons"
|
|
|
|
(dotimes (i (-> obj nb-of-icons))
|
|
(kill-icon obj i)
|
|
)
|
|
0)
|
|
|
|
(defmethod make-enemy-icon hud-battle-enemy ((obj hud-battle-enemy) (idx int) (skel-sym symbol) (enemy-ent entity))
|
|
"make a new icon for the hud"
|
|
|
|
;; make new manipy
|
|
(kill-icon obj 0)
|
|
(hud-pc-replace-icon obj 0 :skel (-> skel-sym value) :entity enemy-ent :z (meters 0.5))
|
|
|
|
0)
|
|
|
|
(defmethod update-display-status hud-battle-enemy ((obj hud-battle-enemy) (skel symbol) (ent entity) (icon-idx int) (trigger-force symbol))
|
|
"logic for displaying or hiding the hud, and drawing the icons."
|
|
|
|
|
|
;; do stuff depending on our current state
|
|
(cond
|
|
((hidden? obj)
|
|
;; we're hidden, so let's make our new icons and see if we are allowed to show
|
|
|
|
;; if we have icons made then show!
|
|
(when (-> obj ready?)
|
|
(set! (-> obj kicked) #f)
|
|
(send-event obj 'show)
|
|
)
|
|
|
|
;; no icons, make new ones but keep them hidden for now
|
|
(when (and (not (-> obj ready?)) skel (not *progress-process*))
|
|
(case skel
|
|
(('*swamp-rat-sg* '*citb-bunny-sg*)
|
|
(set! (-> obj icons icon-idx icon-x) (the int (* 0.84 512)))
|
|
(set! (-> obj icons icon-idx icon-y) (the int (* 0.51 448)))
|
|
(set! (-> obj icons icon-idx scale-x) 0.006)
|
|
)
|
|
(('*gnawer-sg*)
|
|
(set! (-> obj icons icon-idx icon-x) (the int (* 0.78 512)))
|
|
(set! (-> obj icons icon-idx icon-y) (the int (* 0.54 448)))
|
|
(set! (-> obj icons icon-idx scale-x) 0.003)
|
|
)
|
|
(('*flying-lurker-sg*)
|
|
(set! (-> obj icons icon-idx icon-x) (the int (* 0.80 512)))
|
|
(set! (-> obj icons icon-idx icon-y) (the int (* 0.40 448)))
|
|
(set! (-> obj icons icon-idx scale-x) 0.003)
|
|
)
|
|
(else
|
|
(set! (-> obj icons icon-idx icon-x) (the int (* 0.84 512)))
|
|
(set! (-> obj icons icon-idx icon-y) (the int (* 0.51 448)))
|
|
(set! (-> obj icons icon-idx scale-x) 0.004)
|
|
)
|
|
)
|
|
(set! (-> obj icons icon-idx scale-y) (* (-> obj icons icon-idx scale-x) (/ -512.0 448.0)))
|
|
(make-enemy-icon obj icon-idx skel ent)
|
|
(let ((icon0 (the manipy (ppointer->process (-> obj icons icon-idx icon)))))
|
|
(case skel
|
|
(('*babak-sg*)
|
|
(send-event icon0 'art-joint-anim "babak-idle" 0)
|
|
(send-event icon0 'rot-quat (quaternion-axis-angle! (new-stack-quaternion0) 0.0 1.0 0.15 (degrees 210)))
|
|
)
|
|
(('*citb-bunny-sg*)
|
|
(send-event icon0 'art-joint-anim "citb-bunny-idle" 0)
|
|
(send-event icon0 'rot-quat (quaternion-axis-angle! (new-stack-quaternion0) 0.0 1.0 0.15 (degrees 210)))
|
|
)
|
|
(('*bonelurker-sg*)
|
|
(send-event icon0 'art-joint-anim "bonelurker-idle" 0)
|
|
(send-event icon0 'rot-quat (quaternion-axis-angle! (new-stack-quaternion0) 0.0 1.0 0.15 (degrees 210)))
|
|
)
|
|
(('*swamp-rat-sg*)
|
|
(send-event icon0 'art-joint-anim "swamp-rat-celebrate" 0)
|
|
(send-event icon0 'rot-quat (quaternion-axis-angle! (new-stack-quaternion0) 0.0 1.0 0.15 (degrees 210)))
|
|
)
|
|
(('*gnawer-sg*)
|
|
(send-event icon0 'art-joint-anim "gnawer-idle" 0)
|
|
(send-event icon0 'rot-quat (quaternion-axis-angle! (new-stack-quaternion0) 0.0 1.0 0.15 (degrees 210)))
|
|
)
|
|
(('*flying-lurker-sg*)
|
|
(send-event icon0 'art-joint-anim "flying-lurker-fly" 0)
|
|
(send-event icon0 'rot-quat (quaternion-axis-angle! (new-stack-quaternion0) 0.0 1.0 0.15 (degrees 210)))
|
|
)
|
|
)
|
|
(send-event icon0 'draw #f)
|
|
)
|
|
(true! (-> obj ready?))
|
|
)
|
|
)
|
|
(else
|
|
;; we want to be shown!
|
|
|
|
;; progress is open, let's leave.
|
|
(when (and (not (-> obj kicked)) (= *master-mode* 'progress))
|
|
(true! (-> obj kicked))
|
|
(false! (-> obj ready?))
|
|
(send-event obj 'hide-quick)
|
|
)
|
|
|
|
;; set the trigger time so we don't automatically go away
|
|
(if (and trigger-force (!= (-> obj next-state name) 'hud-leaving))
|
|
(set! (-> obj trigger-time) (current-time)))
|
|
)
|
|
)
|
|
0)
|
|
|
|
|
|
(defmacro actor-by-name (name)
|
|
"get an entity by name and cast it to an actor. not super safe!"
|
|
`(the entity-actor (entity-by-name ,name)))
|
|
|
|
(defmacro actor-by-name-safe (name)
|
|
"safe, slower version of actor-by-name"
|
|
`(aif (entity-by-name ,name)
|
|
(if (type-type? it entity-actor)
|
|
(the entity-actor it))
|
|
)
|
|
)
|
|
|
|
(defmethod hud-update hud-battle-enemy ((obj hud-battle-enemy))
|
|
"hud logic."
|
|
|
|
(when (not (-> *pc-settings* extra-hud?))
|
|
(kill-all-icons obj)
|
|
(return #f))
|
|
|
|
(when (and (not (-> obj ready?)) (hidden? obj))
|
|
(kill-all-icons obj)
|
|
)
|
|
|
|
(let ((battle (the process #f))
|
|
(cur-lev (aif (level-get-target-inside *level*) (-> it name)))
|
|
(actor-list-task? #f)
|
|
)
|
|
;; default params
|
|
(set! (-> obj task-entity) #f)
|
|
(set! (-> obj battle-entity) #f)
|
|
(set! (-> obj battle-mode) 'remain)
|
|
|
|
;; find an entity for a battlecontroller, check current level
|
|
(case cur-lev
|
|
(('swamp)
|
|
(set! (-> obj battle-entity) (actor-by-name "swamp-battlecontroller-1"))
|
|
(set! (-> obj want-skel) '*swamp-rat-sg*)
|
|
)
|
|
(('misty)
|
|
(set! (-> obj battle-entity) (actor-by-name "misty-battlecontroller-1"))
|
|
(set! (-> obj want-skel) '*bonelurker-sg*)
|
|
)
|
|
(('citadel)
|
|
(set! (-> obj battle-entity) (actor-by-name "citb-battlecontroller-1"))
|
|
(set! (-> obj want-skel) '*citb-bunny-sg*)
|
|
(set! (-> obj battle-mode) 'alive)
|
|
)
|
|
(('maincave)
|
|
(set! (-> obj task-entity) (the entity-actor (or (actor-by-name "gnawer-11")
|
|
(actor-by-name "gnawer-12")
|
|
(actor-by-name "gnawer-13")
|
|
(actor-by-name "gnawer-14")
|
|
(actor-by-name "gnawer-15")
|
|
(actor-by-name "gnawer-16")
|
|
(actor-by-name "gnawer-17")
|
|
(actor-by-name "gnawer-18")
|
|
(actor-by-name "gnawer-19")
|
|
)))
|
|
(true! actor-list-task?)
|
|
(set! (-> obj want-skel) '*gnawer-sg*)
|
|
)
|
|
(('ogre)
|
|
(when (= 'debug *cheat-mode*)
|
|
(set! (-> obj battle-entity) (actor-by-name "flying-lurker-1"))
|
|
(set! (-> obj want-skel) '*flying-lurker-sg*)
|
|
(set! (-> obj battle-mode) 'alive)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; have an entity, grab its process
|
|
(if (-> obj battle-entity)
|
|
(set! battle (-> obj battle-entity extra process)))
|
|
|
|
(cond
|
|
;; check level statuses FIRST
|
|
((not (aif (level-get *level* (-> obj last-level)) (-> it display?)))
|
|
;; the old level died. kill everything.
|
|
(unless (hidden? obj)
|
|
(set! (-> obj last-battle) INVALID_HANDLE)
|
|
(set! (-> obj last-task) #f)
|
|
(false! (-> obj ready?))
|
|
(kill-all-icons obj)
|
|
(go hud-hidden)
|
|
)
|
|
)
|
|
;; check if we have anything
|
|
((-> obj task-entity)
|
|
;; we have a task to track.
|
|
|
|
;; see if we've changed tracking now
|
|
(when (or (!= (-> obj display-mode?) 'task)
|
|
(!= (-> obj task-entity) (-> obj last-task)))
|
|
(set! (-> obj last-task) (-> obj task-entity))
|
|
(set! (-> obj display-mode?) 'task)
|
|
(false! (-> obj ready?))
|
|
(send-event obj 'hide)
|
|
)
|
|
|
|
;; logic for each kind of task
|
|
(cond
|
|
(actor-list-task?
|
|
;; simple: check a list of actors and count how many have completed their task.
|
|
(set! (-> obj battle-max) 0)
|
|
(set! (-> obj value) 0)
|
|
(let ((actor (-> obj task-entity)))
|
|
|
|
;; get the first actor
|
|
(while (prev-actor actor)
|
|
(set! actor (prev-actor actor)))
|
|
|
|
;; now count forwards.
|
|
(while actor
|
|
|
|
;; stuff.
|
|
(1+! (-> obj battle-max))
|
|
(when (logtest? (-> actor extra perm status) (entity-perm-status complete))
|
|
(1+! (-> obj value))
|
|
)
|
|
|
|
(set! actor (next-actor actor))
|
|
)
|
|
)
|
|
|
|
(when (and (!= (-> obj value) (-> obj battle-max))
|
|
(or (> (-> obj value) 0) (task-closed? (-> obj task-entity task) (task-status need-hint)))
|
|
)
|
|
(update-display-status obj (-> obj want-skel) (-> obj task-entity) 0 #t)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(battle
|
|
;; if its a different process, panic and restart the whole sequence. it's OK
|
|
(when (or (!= (-> obj display-mode?) 'battle)
|
|
(!= (handle->process (-> obj last-battle)) battle))
|
|
(set! (-> obj last-battle) (process->handle battle))
|
|
(set! (-> obj display-mode?) 'battle)
|
|
(false! (-> obj ready?))
|
|
(send-event obj 'hide)
|
|
)
|
|
|
|
;; logic for each kind of process.
|
|
(cond
|
|
((type-type? (-> battle type) battlecontroller)
|
|
(let ((battle (the battlecontroller battle))
|
|
)
|
|
;; wait until battle is active
|
|
(when (= 'battlecontroller-active (-> battle next-state name))
|
|
;; get battle stats
|
|
(let ((alive-count 0))
|
|
(with-children (child battle)
|
|
(1+! alive-count))
|
|
(set! (-> obj value) (- (-> battle spawn-count) alive-count))
|
|
(set! (-> obj battle-max) (-> battle max-spawn-count))
|
|
(set! (-> obj battle-alive) alive-count)
|
|
)
|
|
|
|
(update-display-status obj (-> obj want-skel) (-> obj battle-entity) 0 #t)
|
|
)
|
|
))
|
|
((and (= 'debug *cheat-mode*) (= (-> obj battle-entity) (actor-by-name "flying-lurker-1")))
|
|
(let ((battle (the process-drawable battle)))
|
|
|
|
(if *target*
|
|
(set! (-> obj battle-alive) (the int (/ (vector-vector-distance (-> battle root trans) (target-pos 0)) METER_LENGTH))))
|
|
|
|
(update-display-status obj (-> obj want-skel) (-> obj battle-entity) 0 #t)
|
|
))
|
|
)
|
|
)
|
|
(else
|
|
;; we have nothing. kill everything.
|
|
(unless (hidden? obj)
|
|
(set! (-> obj last-battle) INVALID_HANDLE)
|
|
(set! (-> obj last-task) #f)
|
|
(false! (-> obj ready?))
|
|
(cond
|
|
((and (!= (-> obj next-state name) 'hud-leaving)
|
|
(aif (level-get *level* (-> obj last-level)) (-> it display?))
|
|
)
|
|
(send-event obj 'hide)
|
|
)
|
|
(else
|
|
(kill-all-icons obj)
|
|
(go hud-hidden)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; save the current level
|
|
(set! (-> obj last-level) cur-lev)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
|
|
(defmethod draw-hud hud-battle-enemy ((obj hud-battle-enemy))
|
|
(let ((t9-0 (method-of-type hud draw-hud)))
|
|
(t9-0 obj)
|
|
)
|
|
(with-dma-buffer-add-bucket ((buf (-> (current-frame) global-buf))
|
|
(bucket-id debug))
|
|
(let ((str-x (+ (-> obj text-x) (* (-> obj x-sgn) (-> obj offset))))
|
|
(str-y (/ (* (+ (-> obj text-y) (* (-> obj y-sgn) (-> obj offset)) (-> obj y-offset))
|
|
(the int (-> *video-parms* relative-y-scale)))
|
|
2))
|
|
)
|
|
|
|
(case (-> obj battle-mode)
|
|
(('dead)
|
|
(draw-string-xy (string-format "~D/~D" (-> obj value) (-> obj battle-max))
|
|
buf str-x str-y (font-color white) (font-flags shadow kerning large middle))
|
|
)
|
|
(('alive)
|
|
(draw-string-xy (string-format "~D" (-> obj battle-alive))
|
|
buf str-x str-y (font-color white) (font-flags shadow kerning large middle))
|
|
)
|
|
(('remain)
|
|
(draw-string-xy (string-format "~D" (- (-> obj battle-max) (-> obj value)))
|
|
buf str-x str-y (font-color white) (font-flags shadow kerning large middle))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
|
|
(defmethod init-particles! hud-battle-enemy ((obj hud-battle-enemy) (arg0 int))
|
|
(hud-pc-make-icon obj HUD_ICON_COUNT :skel *fuelcell-naked-sg*
|
|
:x (the int (* 0.84 512)) :y (the int (* 0.51 448)) :z (meters 0.5)
|
|
:scale-x 0.004 :scale-y (* -0.004 (/ 512.0 448.0)))
|
|
(set! (-> obj text-x) (the int (* 0.84 512)))
|
|
(set! (-> obj text-y) (the int (* 0.5 448)))
|
|
(set! (-> obj x-sgn) 1)
|
|
(set! (-> obj y-sgn) 0)
|
|
(set! (-> obj increment-on-event) #t)
|
|
(set-pos-and-scale obj (= (get-aspect-ratio) 'aspect16x9) (= (get-video-mode) 'pal))
|
|
|
|
(set! (-> obj last-battle) INVALID_HANDLE)
|
|
(set! (-> obj last-task) #f)
|
|
(set! (-> obj want-skel) #f)
|
|
(set! (-> obj battle-max) 0)
|
|
|
|
(set! (-> obj last-level) #f)
|
|
(set! (-> obj kicked) #f)
|
|
(set! (-> obj ready?) #f)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;; hud helper funcs
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
(defun deactivate-hud-pc ()
|
|
"kill the pc hud"
|
|
|
|
(dotimes (i HUD_PART_PC_AMOUNT)
|
|
(if (-> *hud-parts-pc* parts i)
|
|
(deactivate (ppointer->process (-> *hud-parts-pc* parts i))))
|
|
)
|
|
0)
|
|
|
|
(defun activate-hud-pc ((tree process-tree))
|
|
"make the pc hud"
|
|
|
|
(deactivate-hud-pc)
|
|
|
|
(set! (-> *hud-parts-pc* battle-enemy) (process-spawn hud-battle-enemy :init hud-init-by-other 0
|
|
:from *pc-dead-pool* :to tree))
|
|
0)
|
|
|
|
|
|
(activate-hud-pc *display-pool*)
|
|
|
|
|
|
|
|
|
|
|