mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 21:27:52 -04:00
b7fe8447e2
* clean up * restore hack
978 lines
26 KiB
Common Lisp
978 lines
26 KiB
Common Lisp
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; name: battlecontroller.gc
|
|
;; name in dgo: battlecontroller
|
|
;; dgos: CIT, L1, MIS, SWA
|
|
|
|
;; DECOMP BEGINS
|
|
|
|
(deftype battlecontroller-spawner (structure)
|
|
((path path-control :offset-assert 0)
|
|
(creature handle :offset-assert 8)
|
|
(trigger-actor entity-actor :offset-assert 16)
|
|
(blocker-actor entity-actor :offset-assert 20)
|
|
(state int8 :offset-assert 24)
|
|
(enabled symbol :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|
|
|
|
(deftype battlecontroller-creature-type (structure)
|
|
((type2 type :offset-assert 0)
|
|
(percent float :offset-assert 4)
|
|
(pickup-percent float :offset-assert 8)
|
|
(pickup-type int32 :offset-assert 12)
|
|
(max-pickup-count int8 :offset-assert 16)
|
|
(pickup-count int8 :offset-assert 17)
|
|
)
|
|
:allow-misaligned :method-count-assert 9
|
|
:size-assert #x12
|
|
:flag-assert #x900000012
|
|
)
|
|
|
|
|
|
(deftype battlecontroller (process-drawable)
|
|
((final-pickup-spawn-point vector :inline :offset-assert 176)
|
|
(activate-distance float :offset-assert 192)
|
|
(max-spawn-count int16 :offset-assert 196)
|
|
(spawn-count int16 :offset-assert 198)
|
|
(die-count int16 :offset-assert 200)
|
|
(target-count int8 :offset-assert 202)
|
|
(spawner-count int8 :offset-assert 203)
|
|
(creature-type-count int8 :offset-assert 204)
|
|
(spawner-array battlecontroller-spawner 8 :inline :offset-assert 208)
|
|
(spawn-period uint64 :offset-assert 464)
|
|
(path-spawn path-control :offset-assert 472)
|
|
(creature-type-array battlecontroller-creature-type 4 :inline :offset-assert 476)
|
|
(final-pickup-type pickup-type :offset-assert 604)
|
|
(prespawn symbol :offset-assert 608)
|
|
(noticed-player symbol :offset-assert 612)
|
|
(camera-on symbol :offset-assert 616)
|
|
(misty-ambush-collision-hack symbol :offset-assert 620)
|
|
(disable-ocean symbol :offset-assert 624)
|
|
(disable-near-ocean symbol :offset-assert 628)
|
|
(disable-mid-ocean symbol :offset-assert 632)
|
|
)
|
|
:heap-base #x210
|
|
:method-count-assert 29
|
|
:size-assert #x27c
|
|
:flag-assert #x1d0210027c
|
|
(:methods
|
|
(dummy-20 () none 20)
|
|
(battlecontroller-idle () _type_ :state 21)
|
|
(battlecontroller-play-intro-camera () _type_ :state 22)
|
|
(dummy-23 () none 23)
|
|
(battlecontroller-active () _type_ :state 24)
|
|
(dummy-25 () none 25)
|
|
(battlecontroller-die () _type_ :state 26)
|
|
(TODO-RENAME-27 (_type_) none 27)
|
|
(cleanup-if-finished! (_type_) none 28)
|
|
)
|
|
)
|
|
|
|
|
|
(defbehavior battlecontroller-spawners-full? battlecontroller ()
|
|
(dotimes (v1-0 (-> self spawner-count))
|
|
(if (= (-> self spawner-array v1-0 creature) #f)
|
|
(return #f)
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
|
|
(defbehavior
|
|
battlecontroller-default-event-handler battlecontroller
|
|
((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
|
|
(case arg2
|
|
(('child-die)
|
|
(+! (-> self die-count) 1)
|
|
(when (= (-> self die-count) (-> self max-spawn-count))
|
|
(let ((v1-4 (the-as process-drawable arg0)))
|
|
(when v1-4
|
|
(set! (-> self final-pickup-spawn-point quad) (-> v1-4 root trans quad))
|
|
(case (-> self final-pickup-type)
|
|
(((pickup-type fuel-cell))
|
|
#f
|
|
)
|
|
(else
|
|
(set! (-> v1-4 fact pickup-type) (-> self final-pickup-type))
|
|
(set! (-> v1-4 fact pickup-amount) 1.0)
|
|
(let ((f0-1 0.0))
|
|
(set! (-> v1-4 fact pickup-spawn-amount) f0-1)
|
|
f0-1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('trigger)
|
|
(go-virtual battlecontroller-die)
|
|
)
|
|
)
|
|
)
|
|
|
|
battlecontroller-default-event-handler
|
|
|
|
(defbehavior battlecontroller-draw-debug battlecontroller ()
|
|
(dotimes (gp-0 (-> self spawner-count))
|
|
(dummy-9 (-> self spawner-array gp-0 path))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior battlecontroller-camera-on battlecontroller ()
|
|
(when (not (-> self camera-on))
|
|
(set! (-> self camera-on) #t)
|
|
(let ((v1-4 (res-lump-struct (-> self entity) 'camera-name structure)))
|
|
(if v1-4
|
|
(send-event *camera* 'change-to-entity-by-name v1-4)
|
|
)
|
|
)
|
|
)
|
|
(the-as object 0)
|
|
)
|
|
|
|
(defbehavior battlecontroller-camera-off battlecontroller ()
|
|
(set! (-> self camera-on) #f)
|
|
(send-event *camera* 'clear-entity)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior battlecontroller-update-spawners battlecontroller ()
|
|
(dotimes (gp-0 (-> self spawner-count))
|
|
(let* ((s5-0 (-> self spawner-array gp-0))
|
|
(s4-0 (handle->process (-> s5-0 creature)))
|
|
)
|
|
(when
|
|
(and s4-0 (logtest? (-> (the-as nav-enemy s4-0) nav-enemy-flags) 2048))
|
|
(cond
|
|
((< (-> s5-0 state) (-> s5-0 path curve num-cverts))
|
|
(when (or (-> self noticed-player) (= (-> s5-0 state) 1))
|
|
(let ((s3-0 (new 'stack-no-clear 'vector)))
|
|
(eval-path-curve-div!
|
|
(-> s5-0 path)
|
|
s3-0
|
|
(the float (-> s5-0 state))
|
|
'interp
|
|
)
|
|
(send-event s4-0 'cue-jump-to-point s3-0)
|
|
)
|
|
(if (zero? (logand (-> (the-as nav-enemy s4-0) nav-enemy-flags) 2048))
|
|
(+! (-> s5-0 state) 1)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(send-event s4-0 'cue-chase)
|
|
(set! (-> s5-0 creature) (the-as handle #f))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior
|
|
battlecontroller-spawn-creature battlecontroller
|
|
((arg0 vector) (arg1 vector))
|
|
(local-vars (v1-25 int))
|
|
(let ((f0-0 (rand-vu))
|
|
(v1-0 0)
|
|
)
|
|
(dotimes (a0-1 (-> self creature-type-count))
|
|
(when (>= f0-0 0.0)
|
|
(set! f0-0 (- f0-0 (-> self creature-type-array a0-1 percent)))
|
|
(if (< f0-0 0.0)
|
|
(set! v1-0 a0-1)
|
|
)
|
|
)
|
|
)
|
|
(let* ((s5-0 (-> self creature-type-array v1-0))
|
|
(s2-0 (-> s5-0 type2))
|
|
(s1-0
|
|
(the-as nav-enemy (get-process *default-dead-pool* s2-0 #x4000))
|
|
)
|
|
(gp-0 (when s1-0
|
|
(let ((t9-2 (method-of-type process activate)))
|
|
(t9-2 s1-0 self s2-0 (the-as pointer #x70004000))
|
|
)
|
|
(run-now-in-process
|
|
s1-0
|
|
nav-enemy-init-by-other
|
|
self
|
|
arg0
|
|
arg1
|
|
)
|
|
(-> s1-0 ppointer)
|
|
)
|
|
)
|
|
)
|
|
(if (and gp-0 (zero? (-> (the-as (pointer nav-enemy) gp-0) 0 enemy-info)))
|
|
(set! gp-0 (the-as (pointer process) #f))
|
|
)
|
|
(when (the-as (pointer nav-enemy) gp-0)
|
|
(logclear!
|
|
(-> (the-as (pointer nav-enemy) gp-0) 0 mask)
|
|
(process-mask actor-pause)
|
|
)
|
|
(if (-> self misty-ambush-collision-hack)
|
|
(logior! (-> (the-as (pointer nav-enemy) gp-0) 0 nav-enemy-flags) #x8000)
|
|
)
|
|
(+! (-> self spawn-count) 1)
|
|
(-> self fact pickup-type)
|
|
(cond
|
|
((and
|
|
(< (-> s5-0 pickup-count) (-> s5-0 max-pickup-count))
|
|
(rand-vu-percent? (-> s5-0 pickup-percent))
|
|
)
|
|
(+! (-> s5-0 pickup-count) 1)
|
|
(set! v1-25 (-> s5-0 pickup-type))
|
|
)
|
|
(else
|
|
(set! v1-25 (the-as int (-> self fact pickup-type)))
|
|
)
|
|
)
|
|
(set!
|
|
(-> (the-as (pointer nav-enemy) gp-0) 0 enemy-info pickup-type)
|
|
(the-as pickup-type v1-25)
|
|
)
|
|
(cond
|
|
((= v1-25 7)
|
|
)
|
|
((zero? v1-25)
|
|
(set!
|
|
(-> (the-as (pointer nav-enemy) gp-0) 0 enemy-info pickup-amount)
|
|
0.0
|
|
)
|
|
(set!
|
|
(-> (the-as (pointer nav-enemy) gp-0) 0 enemy-info pickup-spawn-amount)
|
|
0.0
|
|
)
|
|
)
|
|
(else
|
|
(set!
|
|
(-> (the-as (pointer nav-enemy) gp-0) 0 enemy-info pickup-amount)
|
|
1.0
|
|
)
|
|
(set!
|
|
(-> (the-as (pointer nav-enemy) gp-0) 0 enemy-info pickup-spawn-amount)
|
|
0.0
|
|
)
|
|
(logior! (-> (the-as (pointer nav-enemy) gp-0) 0 enemy-info options) 512)
|
|
(set!
|
|
(-> (the-as (pointer nav-enemy) gp-0) 0 enemy-info fade-time)
|
|
(the-as uint 1200)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(the-as handle (ppointer->handle gp-0))
|
|
)
|
|
)
|
|
)
|
|
|
|
(defbehavior
|
|
battlecontroller-spawn-creature-at-spawner battlecontroller
|
|
((arg0 int) (arg1 int))
|
|
(let* ((s5-0 (-> self spawner-array arg0))
|
|
(s3-0 (-> s5-0 path))
|
|
(s4-0
|
|
(eval-path-curve-div!
|
|
s3-0
|
|
(new 'stack-no-clear 'vector)
|
|
(the float arg1)
|
|
'interp
|
|
)
|
|
)
|
|
(a1-3
|
|
(eval-path-curve-div!
|
|
s3-0
|
|
(new 'stack-no-clear 'vector)
|
|
(the float (+ arg1 1))
|
|
'interp
|
|
)
|
|
)
|
|
)
|
|
(when
|
|
(and
|
|
(not (handle->process (-> s5-0 creature)))
|
|
(< (-> self spawn-count) (-> self max-spawn-count))
|
|
)
|
|
(let ((v1-10 (battlecontroller-spawn-creature s4-0 a1-3)))
|
|
(when (handle->process v1-10)
|
|
(set! (-> s5-0 creature) v1-10)
|
|
(set! (-> s5-0 state) (+ arg1 1))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior battlecontroller-spawn-creature-random-spawner battlecontroller ()
|
|
(let* ((gp-0 (rand-vu-int-count (-> self spawner-count)))
|
|
(v1-2 (-> self spawner-array gp-0))
|
|
)
|
|
(when (and (-> v1-2 enabled) (-> v1-2 blocker-actor))
|
|
(when
|
|
(logtest?
|
|
(-> v1-2 blocker-actor extra perm status)
|
|
(entity-perm-status complete)
|
|
)
|
|
(set! (-> v1-2 enabled) #f)
|
|
(let ((a0-9 0))
|
|
(dotimes (a1-0 (-> self spawner-count))
|
|
(if (-> self spawner-array a1-0 enabled)
|
|
(+! a0-9 1)
|
|
)
|
|
)
|
|
(if (zero? a0-9)
|
|
(set! (-> self spawn-count) (-> self max-spawn-count))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (and (-> v1-2 enabled) (not (handle->process (-> v1-2 creature))))
|
|
(let ((a1-7 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> a1-7 from) self)
|
|
(set! (-> a1-7 num-params) 0)
|
|
(set! (-> a1-7 message) 'spawn)
|
|
(let ((t9-1 send-event-function)
|
|
(v1-3 (-> v1-2 trigger-actor))
|
|
)
|
|
(t9-1 (if v1-3
|
|
(-> v1-3 extra process)
|
|
)
|
|
a1-7
|
|
)
|
|
)
|
|
)
|
|
(battlecontroller-spawn-creature-at-spawner gp-0 0)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior battlecontroller-fill-all-spawners battlecontroller ()
|
|
(dotimes (gp-0 (-> self spawner-count))
|
|
(battlecontroller-spawn-creature-at-spawner gp-0 1)
|
|
)
|
|
(when (nonzero? (-> self path-spawn))
|
|
(let ((gp-1 (new 'stack-no-clear 'vector)))
|
|
(dotimes (s5-0 (-> self path-spawn curve num-cverts))
|
|
(eval-path-curve-div! (-> self path-spawn) gp-1 (the float s5-0) 'interp)
|
|
(let ((s4-0 (battlecontroller-spawn-creature gp-1 (-> self root trans))))
|
|
(when (handle->process s4-0)
|
|
(suspend)
|
|
(send-event (handle->process s4-0) 'cue-chase)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior battlecontroller-battle-begin battlecontroller ()
|
|
(set-setting! *setting-control* self 'music 'danger 0.0 0)
|
|
(let ((gp-0 (entity-actor-count (-> self entity) 'kill-actor)))
|
|
(dotimes (s5-0 gp-0)
|
|
(let ((v1-2 (entity-actor-lookup (-> self entity) 'kill-actor s5-0)))
|
|
(if v1-2
|
|
(logior! (-> v1-2 extra perm status) (entity-perm-status bit-9))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((gp-1 (entity-actor-count (-> self entity) 'trigger-actor)))
|
|
(dotimes (s5-1 gp-1)
|
|
(let ((s4-0 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> s4-0 from) self)
|
|
(set! (-> s4-0 num-params) 0)
|
|
(set! (-> s4-0 message) 'trigger)
|
|
(let ((s3-0 send-event-function)
|
|
(v1-7 (entity-actor-lookup (-> self entity) 'trigger-actor s5-1))
|
|
)
|
|
(s3-0 (if v1-7
|
|
(-> v1-7 extra process)
|
|
)
|
|
s4-0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(level-hint-spawn
|
|
(game-text-id zero)
|
|
(the-as string #f)
|
|
(-> self entity)
|
|
*entity-pool*
|
|
(game-task none)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior battlecontroller-off battlecontroller ()
|
|
(clear-pending-settings-from-process *setting-control* self 'music)
|
|
(let ((gp-0 (entity-actor-count (-> self entity) 'kill-actor)))
|
|
(dotimes (s5-0 gp-0)
|
|
(let ((v1-2 (entity-actor-lookup (-> self entity) 'kill-actor s5-0)))
|
|
(if v1-2
|
|
(logclear! (-> v1-2 extra perm status) (entity-perm-status bit-9))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior battlecontroller-battle-end battlecontroller ()
|
|
(case (-> (level-get-target-inside *level*) name)
|
|
(('citadel)
|
|
(level-hint-spawn
|
|
(game-text-id misty-battle-finished)
|
|
"sksp0378"
|
|
(the-as entity #f)
|
|
*entity-pool*
|
|
(game-task none)
|
|
)
|
|
)
|
|
)
|
|
(battlecontroller-off)
|
|
(none)
|
|
)
|
|
|
|
(defstate battlecontroller-idle (battlecontroller)
|
|
:virtual #t
|
|
:event
|
|
battlecontroller-default-event-handler
|
|
:trans
|
|
(behavior ()
|
|
0
|
|
(none)
|
|
)
|
|
:code
|
|
(behavior ()
|
|
(set! (-> self state-time) (-> *display* base-frame-counter))
|
|
(if (-> self prespawn)
|
|
(battlecontroller-fill-all-spawners)
|
|
)
|
|
(while #t
|
|
(when (>= (- (-> *display* base-frame-counter) (-> self state-time)) 30)
|
|
(set! (-> self state-time) (-> *display* base-frame-counter))
|
|
(when
|
|
(and
|
|
*target*
|
|
(>=
|
|
(-> self activate-distance)
|
|
(vector-vector-distance
|
|
(-> self root trans)
|
|
(-> *target* control trans)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> self noticed-player) #t)
|
|
(battlecontroller-battle-begin)
|
|
(when (not (-> self prespawn))
|
|
(battlecontroller-fill-all-spawners)
|
|
(suspend)
|
|
0
|
|
)
|
|
(go-virtual battlecontroller-play-intro-camera)
|
|
)
|
|
)
|
|
(suspend)
|
|
)
|
|
(none)
|
|
)
|
|
:post
|
|
(the-as (function none :behavior battlecontroller) #f)
|
|
)
|
|
|
|
(defstate battlecontroller-play-intro-camera (battlecontroller)
|
|
:virtual #t
|
|
:event
|
|
battlecontroller-default-event-handler
|
|
:enter
|
|
(behavior ()
|
|
(process-entity-status! self (entity-perm-status bit-3) #t)
|
|
(none)
|
|
)
|
|
:exit
|
|
(behavior ()
|
|
(process-entity-status! self (entity-perm-status bit-3) #f)
|
|
(none)
|
|
)
|
|
:code
|
|
(behavior ()
|
|
(go-virtual battlecontroller-active)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
(defbehavior battlecontroller-disable-ocean battlecontroller ()
|
|
(set! *ocean-off* (-> self disable-ocean))
|
|
(set! *ocean-mid-off* (-> self disable-mid-ocean))
|
|
(set! *ocean-near-off* (-> self disable-near-ocean))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defstate battlecontroller-active (battlecontroller)
|
|
:virtual #t
|
|
:event
|
|
battlecontroller-default-event-handler
|
|
:trans
|
|
(behavior ()
|
|
(if
|
|
(and
|
|
*target*
|
|
(>=
|
|
(-> self activate-distance)
|
|
(vector-vector-distance (-> self root trans) (-> *target* control trans))
|
|
)
|
|
)
|
|
(level-hint-spawn
|
|
(game-text-id zero)
|
|
(the-as string #f)
|
|
(-> self entity)
|
|
*entity-pool*
|
|
(game-task none)
|
|
)
|
|
)
|
|
(battlecontroller-disable-ocean)
|
|
(battlecontroller-update-spawners)
|
|
(none)
|
|
)
|
|
:code
|
|
(behavior ()
|
|
(set! (-> self state-time) (-> *display* base-frame-counter))
|
|
(battlecontroller-camera-on)
|
|
(while #t
|
|
(when (>= (- (-> *display* base-frame-counter) (-> self state-time)) 30)
|
|
(set! (-> self state-time) (-> *display* base-frame-counter))
|
|
(let ((gp-0 0))
|
|
(let ((v1-8 (-> self child)))
|
|
(while v1-8
|
|
(+! gp-0 1)
|
|
(set! v1-8 (-> v1-8 0 brother))
|
|
(nop!)
|
|
(nop!)
|
|
)
|
|
)
|
|
(if (and (zero? gp-0) (= (-> self spawn-count) (-> self max-spawn-count)))
|
|
(go-virtual battlecontroller-die)
|
|
)
|
|
(when (< gp-0 (-> self target-count))
|
|
(let ((gp-1 (-> *display* base-frame-counter)))
|
|
(until
|
|
(>=
|
|
(- (-> *display* base-frame-counter) gp-1)
|
|
(the-as int (-> self spawn-period))
|
|
)
|
|
(suspend)
|
|
)
|
|
)
|
|
(battlecontroller-spawn-creature-random-spawner)
|
|
)
|
|
)
|
|
)
|
|
(suspend)
|
|
)
|
|
(none)
|
|
)
|
|
:post
|
|
(the-as (function none :behavior battlecontroller) #f)
|
|
)
|
|
|
|
(defbehavior battlecontroller-special-contents? battlecontroller ()
|
|
(= (-> self final-pickup-type) (pickup-type fuel-cell))
|
|
)
|
|
|
|
(defbehavior battlecontroller-special-contents-collected? battlecontroller ()
|
|
(= (-> self entity extra perm user-int8 0) 2)
|
|
)
|
|
|
|
(defbehavior battlecontroller-set-special-contents-collected battlecontroller ()
|
|
(let ((v1-2 (-> self entity extra perm)))
|
|
(logior! (-> v1-2 status) (entity-perm-status user-set-from-cstage))
|
|
(set! (-> v1-2 user-int8 0) 2)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defbehavior battlecontroller-task-completed? battlecontroller ()
|
|
(>= (-> self entity extra perm user-int8 0) 1)
|
|
)
|
|
|
|
(defbehavior battlecontroller-set-task-completed battlecontroller ()
|
|
(let ((v1-2 (-> self entity extra perm)))
|
|
(logior! (-> v1-2 status) (entity-perm-status user-set-from-cstage))
|
|
(set! (-> v1-2 user-int8 0) 1)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defstate battlecontroller-die (battlecontroller)
|
|
:virtual #t
|
|
:event
|
|
(the-as
|
|
(function process int symbol event-message-block object :behavior battlecontroller)
|
|
process-drawable-fuel-cell-handler
|
|
)
|
|
:code
|
|
(behavior ()
|
|
(sound-play-by-name
|
|
(static-sound-name "money-pickup")
|
|
(new-sound-id)
|
|
1024
|
|
-2286
|
|
0
|
|
(the-as uint 1)
|
|
(the-as vector #f)
|
|
)
|
|
(battlecontroller-battle-end)
|
|
(battlecontroller-camera-off)
|
|
(battlecontroller-set-task-completed)
|
|
(countdown (gp-1 (entity-actor-count (-> self entity) 'fade-actor))
|
|
(let ((s5-1 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> s5-1 from) self)
|
|
(set! (-> s5-1 num-params) 0)
|
|
(set! (-> s5-1 message) 'fade)
|
|
(let ((s4-0 send-event-function)
|
|
(v1-2 (entity-actor-lookup (-> self entity) 'fade-actor gp-1))
|
|
)
|
|
(s4-0 (if v1-2
|
|
(-> v1-2 extra process)
|
|
)
|
|
s5-1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(countdown (gp-2 (entity-actor-count (-> self entity) 'alt-actor))
|
|
(let ((s5-2 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> s5-2 from) self)
|
|
(set! (-> s5-2 num-params) 0)
|
|
(set! (-> s5-2 message) 'trigger)
|
|
(let ((s4-1 send-event-function)
|
|
(v1-8 (entity-actor-lookup (-> self entity) 'alt-actor gp-2))
|
|
)
|
|
(s4-1 (if v1-8
|
|
(-> v1-8 extra process)
|
|
)
|
|
s5-2
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when
|
|
(and
|
|
(battlecontroller-special-contents?)
|
|
(not (battlecontroller-special-contents-collected?))
|
|
)
|
|
(label cfg-15)
|
|
(birth-pickup-at-point
|
|
(-> self final-pickup-spawn-point)
|
|
(the-as int (-> self final-pickup-type))
|
|
(the float (-> self entity extra perm task))
|
|
#f
|
|
self
|
|
#f
|
|
)
|
|
(when (not (-> self child))
|
|
(suspend)
|
|
(goto cfg-15)
|
|
)
|
|
(while (-> self child)
|
|
(suspend)
|
|
)
|
|
(battlecontroller-set-special-contents-collected)
|
|
)
|
|
(while (-> self child)
|
|
(suspend)
|
|
)
|
|
(process-entity-status! self (entity-perm-status dead) #t)
|
|
(none)
|
|
)
|
|
:post
|
|
(the-as (function none :behavior battlecontroller) #f)
|
|
)
|
|
|
|
(defmethod relocate battlecontroller ((obj battlecontroller) (arg0 int))
|
|
(dotimes (v1-0 (-> obj spawner-count))
|
|
(let ((a0-3 (-> obj spawner-array v1-0)))
|
|
(if (nonzero? (-> a0-3 path))
|
|
(&+! (-> a0-3 path) arg0)
|
|
)
|
|
)
|
|
)
|
|
(if (nonzero? (-> obj path-spawn))
|
|
(&+! (-> obj path-spawn) arg0)
|
|
)
|
|
(the-as
|
|
battlecontroller
|
|
((the-as
|
|
(function process-drawable int process-drawable)
|
|
(find-parent-method battlecontroller 7)
|
|
)
|
|
obj
|
|
arg0
|
|
)
|
|
)
|
|
)
|
|
|
|
(defmethod deactivate battlecontroller ((obj battlecontroller))
|
|
(with-pp
|
|
(let ((gp-0 pp))
|
|
(let ((s6-1 obj))
|
|
)
|
|
(battlecontroller-off)
|
|
(let ((s6-2 gp-0))
|
|
)
|
|
)
|
|
((the-as
|
|
(function process-drawable none)
|
|
(find-parent-method battlecontroller 10)
|
|
)
|
|
obj
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
(defmethod TODO-RENAME-27 battlecontroller ((obj battlecontroller))
|
|
(local-vars (sv-16 res-tag))
|
|
(set!
|
|
(-> obj fact)
|
|
(new
|
|
'process
|
|
'fact-info
|
|
obj
|
|
(pickup-type eco-pill-random)
|
|
(-> *FACT-bank* default-pill-inc)
|
|
)
|
|
)
|
|
(set! (-> obj path) (new 'process 'path-control obj 'path 0.0))
|
|
(logior!
|
|
(-> obj path flags)
|
|
(path-control-flag display draw-line draw-point draw-text)
|
|
)
|
|
(set! (-> obj activate-distance) 122880.0)
|
|
(let ((s5-0 0))
|
|
(let* ((s4-0 '(patha pathb pathc pathd pathe pathf pathg pathh))
|
|
(s2-0 (car s4-0))
|
|
)
|
|
(while (not (null? s4-0))
|
|
(let
|
|
((v1-7 (res-lump-struct (-> obj entity) (the-as symbol s2-0) structure))
|
|
(s3-0 (-> obj spawner-array s5-0))
|
|
)
|
|
(when (and v1-7 (< s5-0 8))
|
|
(set!
|
|
(-> s3-0 path)
|
|
(new 'process 'path-control obj (the-as symbol s2-0) 0.0)
|
|
)
|
|
(set! (-> s3-0 creature) (the-as handle #f))
|
|
(set! (-> s3-0 trigger-actor) #f)
|
|
(set! (-> s3-0 blocker-actor) #f)
|
|
(set! (-> s3-0 enabled) #t)
|
|
(logior!
|
|
(-> s3-0 path flags)
|
|
(path-control-flag display draw-line draw-point draw-text)
|
|
)
|
|
(+! s5-0 1)
|
|
)
|
|
)
|
|
(set! s4-0 (cdr s4-0))
|
|
(set! s2-0 (car s4-0))
|
|
)
|
|
)
|
|
(set! (-> obj spawner-count) s5-0)
|
|
)
|
|
0
|
|
(if (res-lump-struct (-> obj entity) 'pathspawn structure)
|
|
(set! (-> obj path-spawn) (new 'process 'path-control obj 'pathspawn 0.0))
|
|
)
|
|
(let ((s5-1 (entity-actor-count (-> obj entity) 'spawner-trigger-actor)))
|
|
(dotimes (s4-1 s5-1)
|
|
(if (< s4-1 (-> obj spawner-count))
|
|
(set!
|
|
(-> obj spawner-array s4-1 trigger-actor)
|
|
(entity-actor-lookup (-> obj entity) 'spawner-trigger-actor s4-1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((s5-2 (entity-actor-count (-> obj entity) 'spawner-blocker-actor)))
|
|
(dotimes (s4-2 s5-2)
|
|
(if (< s4-2 (-> obj spawner-count))
|
|
(set!
|
|
(-> obj spawner-array s4-2 blocker-actor)
|
|
(entity-actor-lookup (-> obj entity) 'spawner-blocker-actor s4-2)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set!
|
|
(-> obj spawn-period)
|
|
(the-as
|
|
uint
|
|
(the int (* 300.0 (res-lump-float (-> obj entity) 'delay :default 0.1)))
|
|
)
|
|
)
|
|
(set! (-> obj target-count) 10)
|
|
(set! (-> obj max-spawn-count) 100)
|
|
(set! (-> obj spawn-count) 0)
|
|
(set! (-> obj die-count) 0)
|
|
(set! (-> obj creature-type-count) 1)
|
|
(set! (-> obj noticed-player) #f)
|
|
(set! (-> obj camera-on) #f)
|
|
(let ((v1-46 (res-lump-data (-> obj entity) 'num-lurkers (pointer int32))))
|
|
(when v1-46
|
|
(set! (-> obj target-count) (-> v1-46 0))
|
|
(set! (-> obj max-spawn-count) (-> v1-46 1))
|
|
)
|
|
)
|
|
(set! (-> obj creature-type-array 0 type2) babak)
|
|
(set! (-> obj creature-type-array 0 percent) 1.0)
|
|
(let ((s5-3 0))
|
|
(set! sv-16 (new 'static 'res-tag))
|
|
(let
|
|
((v1-49
|
|
(res-lump-data (-> obj entity) 'lurker-type pointer :tag-ptr (& sv-16))
|
|
)
|
|
)
|
|
(when v1-49
|
|
(dotimes (a0-22 (the-as int (-> sv-16 elt-count)))
|
|
(let ((a1-15 (-> (the-as (pointer uint32) (&+ v1-49 (* a0-22 4))))))
|
|
(when (nonzero? a1-15)
|
|
(set! (-> obj creature-type-array s5-3 type2) (the-as type a1-15))
|
|
(+! s5-3 1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj creature-type-count) s5-3)
|
|
)
|
|
(let ((v1-52 (res-lump-data (-> obj entity) 'percent pointer))
|
|
(f0-6 0.0)
|
|
)
|
|
(when v1-52
|
|
(dotimes (a0-26 (-> obj creature-type-count))
|
|
(set!
|
|
(-> obj creature-type-array a0-26 percent)
|
|
(fabs (-> (the-as (pointer float) (&+ v1-52 (* a0-26 4)))))
|
|
)
|
|
(+! f0-6 (-> obj creature-type-array a0-26 percent))
|
|
)
|
|
(cond
|
|
((= f0-6 0.0)
|
|
(set! (-> obj creature-type-count) 1)
|
|
(set! (-> obj creature-type-array 0 percent) 1.0)
|
|
)
|
|
(else
|
|
(let ((f0-9 (/ 1.0 f0-6)))
|
|
(dotimes (v1-57 (-> obj creature-type-count))
|
|
(set!
|
|
(-> obj creature-type-array 0 percent)
|
|
(* (-> obj creature-type-array 0 percent) f0-9)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set!
|
|
(-> obj final-pickup-type)
|
|
(res-lump-value
|
|
(-> obj entity)
|
|
'final-pickup
|
|
pickup-type
|
|
:default
|
|
(the-as uint128 7)
|
|
)
|
|
)
|
|
(let ((s5-4 (res-lump-data (-> obj entity) 'pickup-type pointer))
|
|
(s4-3 (res-lump-data (-> obj entity) 'max-pickup-count pointer))
|
|
(v1-63 (res-lump-data (-> obj entity) 'pickup-percent pointer))
|
|
)
|
|
(dotimes (a0-34 (-> obj creature-type-count))
|
|
(let ((a1-34 (-> obj creature-type-array a0-34)))
|
|
(set! (-> a1-34 pickup-count) 0)
|
|
(if s5-4
|
|
(set!
|
|
(-> a1-34 pickup-type)
|
|
(-> (the-as (pointer int32) (&+ s5-4 (* a0-34 4))))
|
|
)
|
|
)
|
|
(if s4-3
|
|
(set!
|
|
(-> a1-34 max-pickup-count)
|
|
(-> (the-as (pointer int32) (&+ s4-3 (* a0-34 4))))
|
|
)
|
|
)
|
|
(if v1-63
|
|
(set!
|
|
(-> a1-34 pickup-percent)
|
|
(-> (the-as (pointer float) (&+ v1-63 (* a0-34 4))))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj misty-ambush-collision-hack) #f)
|
|
(set! (-> obj disable-ocean) #f)
|
|
(set! (-> obj disable-mid-ocean) #f)
|
|
(set! (-> obj disable-near-ocean) #t)
|
|
(set! (-> obj final-pickup-spawn-point quad) (-> obj root trans quad))
|
|
(set! (-> obj prespawn) (= (res-lump-value (-> obj entity) 'mode uint128) 1))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defmethod cleanup-if-finished! battlecontroller ((obj battlecontroller))
|
|
(if (battlecontroller-task-completed?)
|
|
(go (method-of-object obj battlecontroller-die))
|
|
(go (method-of-object obj battlecontroller-idle))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
(defmethod
|
|
copy-defaults!
|
|
battlecontroller
|
|
((obj battlecontroller) (arg0 res-lump))
|
|
(set! (-> obj mask) (logior (process-mask enemy) (-> obj mask)))
|
|
(set! (-> obj root) (new 'process 'trsqv))
|
|
(process-drawable-from-entity! obj arg0)
|
|
(TODO-RENAME-27 obj)
|
|
(cleanup-if-finished! obj)
|
|
(none)
|
|
)
|
|
|
|
|
|
|
|
|