mirror/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project synced 2026-08-07 02:06:59 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
4e19f9435e951ded7c2dca0fe05095dbdc3b697b
jak-project/goal_src/jak1/pc/hud-classes-pc.gc
T
Matt Dallmeyer feaa7fb873 [jak1] Show max of flying-lurker distances on HUD (#4309) 
previously only showed the distance from `flying-lurker-1`, but any of
the 3 getting 500m can cause you to fail, so we should show the max
2026-06-11 07:26:41 +01:00

470 lines
20 KiB
Common Lisp
Raw Blame History

;;-*-Lisp-*-
(in-package goal)
(require "engine/ui/hud.gc")
(require "levels/common/battlecontroller.gc")
#| 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 ((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 ((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 ((obj hud-battle-enemy))
"kill all hud icons"
(dotimes (i (-> obj nb-of-icons))
(kill-icon obj i))
0)
(defmethod make-enemy-icon ((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 ((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!
(false! (-> obj ready?))
;; progress is open, let's leave.
(when (and (not (-> obj kicked)) (= *master-mode* 'progress))
(true! (-> obj kicked))
(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 ((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")))
(when *target*
(let* ((lurker1 (the process-drawable battle))
(dist1 (if lurker1 (vector-vector-distance (-> lurker1 root trans) (target-pos 0)) 0.0))
(lurker2 (the process-drawable (process-by-ename "flying-lurker-2")))
(dist2 (if lurker2 (vector-vector-distance (-> lurker2 root trans) (target-pos 0)) 0.0))
(lurker3 (the process-drawable (process-by-ename "flying-lurker-3")))
(dist3 (if lurker3 (vector-vector-distance (-> lurker3 root trans) (target-pos 0)) 0.0)))
(set! (-> obj battle-alive) (the int (/ (fmax dist1 dist2 dist3) METER_LENGTH)))))
(update-display-status obj (-> obj want-skel) (-> obj battle-entity) 0 #t))))
(else
;; we have nothing. kill everything.
(unless (and (= (-> obj last-battle) INVALID_HANDLE) (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 ((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! ((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*)
Reference in New Issue View Git Blame Copy Permalink