mirror of
https://github.com/open-goal/jak-project
synced 2026-06-21 08:41:48 -04:00
Hat Kid
bdee98323d
Adds the following files: - `amphibian` - `centurion` - `ginsu` - `grenadier` - `hopper` - `metalmonk` - `monster-frog` - `predator-graph` - `predator-h` - `predator` - `rapid-gunner` - `rhino` - `rhino-wall` - `tomb-baby-spider` Also adds the DGOs for the following levels: - Mar's Tomb - Mountain Temple - Drill Platform - Sacred Site (Sage Hut) Manual patches: - The decompiler emits `(b! #t cfg-17)` in `(trans hostile hopper)` without putting a `(label cfg-17)` anywhere - Added cast to `art-joint-anim` in `(code broken rhino-wall)` and `(code hit rhino-wall)` Other notes: - `amphibian` seems to occasionally crash when using its tongue attack. Haven't investigated this yet - `ginsu` crashes after being killed somewhere in the `deactivate` method, possibly because of its `part-spawner` - Predators aren't spawning in the forest hunt mission, not sure if `forest-obs` might be needed for that or if it's something else - The `rhino-wall` STR animation seems to load (albeit a bit broken due to missing VAG stream playback), but causes the viewport to shrink as soon as it's played - I added `pegasus::74` to the `event_handler_hack` bool in `variable_naming.cpp` because I got a `none` cast after changing the return value of `enemy::74`
3884 lines
138 KiB
Common Lisp
Vendored
Generated
3884 lines
138 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition for method 9 of type enemy-info
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod copy-enemy-info! enemy-info ((obj enemy-info) (obj-to-copy enemy-info))
|
|
"Copies the given [[enemy-info]] into the current [[enemy-info]]"
|
|
(mem-copy! (&-> obj type) (&-> obj-to-copy type) 384)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for symbol *enemy-dummy-shadow-control*, type shadow-control
|
|
(define *enemy-dummy-shadow-control*
|
|
(new 'static 'shadow-control :settings (new 'static 'shadow-settings
|
|
:flags (shadow-flags shdf03 disable-draw)
|
|
:shadow-dir (new 'static 'vector :y -1.0 :w 614400.0)
|
|
:bot-plane (new 'static 'plane :y 1.0 :w 4096.0)
|
|
:top-plane (new 'static 'plane :y 1.0 :w -4096.0)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 7 of type enemy
|
|
;; WARN: Return type mismatch process-focusable vs enemy.
|
|
(defmethod relocate enemy ((obj enemy) (arg0 int))
|
|
(if (nonzero? (-> obj neck))
|
|
(&+! (-> obj neck) arg0)
|
|
)
|
|
(the-as
|
|
enemy
|
|
((the-as (function process-focusable int process-focusable) (find-parent-method enemy 7)) obj arg0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 117 of type enemy
|
|
(defmethod get-rand-float enemy ((obj enemy))
|
|
"@returns the result of calling [[rand-vu]]"
|
|
(rand-vu)
|
|
)
|
|
|
|
;; definition for method 118 of type enemy
|
|
(defmethod get-rand-float-range enemy ((obj enemy) (low float) (high float))
|
|
"@param low The lower bound of the range (inclusive)
|
|
@param high The upper bound of the range (exclusive)
|
|
@returns A random float in the specified range"
|
|
(+ low (* (rand-vu) (- high low)))
|
|
)
|
|
|
|
;; definition for method 119 of type enemy
|
|
(defmethod get-rand-int enemy ((obj enemy) (high int))
|
|
"@param high The upper bound of the range (exclusive)
|
|
@returns a random integer in the range 0 to `high`
|
|
@see [[rand-vu]]"
|
|
(the int (* (rand-vu) (the float high)))
|
|
)
|
|
|
|
;; definition for method 121 of type enemy
|
|
(defmethod get-rand-int-range enemy ((obj enemy) (low int) (high int))
|
|
"@param low The lower bound of the range (inclusive)
|
|
@param high The upper bound of the range (exclusive)
|
|
@returns A random integer in the specified range"
|
|
(+ low (the int (* (rand-vu) (the float (+ (- 1 low) high)))))
|
|
)
|
|
|
|
;; definition for method 122 of type enemy
|
|
(defmethod rng-hit? enemy ((obj enemy) (chance float))
|
|
"TODO - not the best name
|
|
@param chance The value to compare ([[>=]]) with the result from [[rand-vu]].
|
|
@returns If `chance` is greater than the random draw"
|
|
(>= chance (rand-vu))
|
|
)
|
|
|
|
;; definition for method 120 of type enemy
|
|
;; WARN: new jak 2 until loop case, check carefully
|
|
(defmethod enemy-method-120 enemy ((obj enemy) (arg0 int) (arg1 int))
|
|
"TODO"
|
|
(let ((v1-0 0)
|
|
(s5-0 0)
|
|
)
|
|
(let ((a2-1 1))
|
|
(while (nonzero? arg0)
|
|
(+! arg0 -1)
|
|
(if (not (logtest? arg1 a2-1))
|
|
(+! v1-0 1)
|
|
)
|
|
(set! a2-1 (* a2-1 2))
|
|
)
|
|
)
|
|
(when (> v1-0 0)
|
|
(let ((v1-1 (get-rand-int obj v1-0))
|
|
(a0-1 1)
|
|
)
|
|
(until #f
|
|
(while (logtest? arg1 a0-1)
|
|
(nop!)
|
|
(nop!)
|
|
(+! s5-0 1)
|
|
(set! a0-1 (* a0-1 2))
|
|
)
|
|
(if (zero? v1-1)
|
|
(goto cfg-14)
|
|
)
|
|
(+! v1-1 -1)
|
|
(+! s5-0 1)
|
|
(set! a0-1 (* a0-1 2))
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
(label cfg-14)
|
|
s5-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 123 of type enemy
|
|
(defmethod enemy-method-123 enemy ((obj enemy) (arg0 float))
|
|
"TODO"
|
|
(let* ((v1-5 (-> *display* frames (-> *display* last-screen) run-time))
|
|
(f1-2 (fmax 0.0 (fmin 1.0 (* 0.001 (+ -7000.0 (the float v1-5))))))
|
|
)
|
|
(>= (+ arg0 (* f1-2 (- 1.0 arg0))) (rand-vu))
|
|
)
|
|
)
|
|
|
|
;; definition for method 60 of type enemy
|
|
(defmethod coin-flip? enemy ((obj enemy))
|
|
"@returns The result of a 50/50 RNG roll"
|
|
(zero? (get-rand-int obj 2))
|
|
)
|
|
|
|
;; definition for method 12 of type enemy
|
|
;; WARN: disable def twice: 40. This may happen when a cond (no else) is nested inside of another conditional, but it should be rare.
|
|
(defmethod run-logic? enemy ((obj enemy))
|
|
(cond
|
|
((logtest? (-> obj mask) (process-mask actor-pause))
|
|
(let ((draw (-> obj draw)))
|
|
(or (and (nonzero? draw)
|
|
(>= (+ (-> *ACTOR-bank* pause-dist) (-> obj root-override2 pause-adjust-distance))
|
|
(vector-vector-distance (-> obj root-override2 trans) (camera-pos))
|
|
)
|
|
(or (logtest? (-> draw status) (draw-control-status on-screen))
|
|
(not (and (-> obj next-state) (= (-> obj next-state name) 'idle)))
|
|
)
|
|
)
|
|
(and (nonzero? (-> obj skel)) (!= (-> obj skel root-channel 0) (-> obj skel channel)))
|
|
(and (nonzero? draw) (logtest? (-> draw status) (draw-control-status uninited)))
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
#t
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 53 of type enemy
|
|
;; WARN: Return type mismatch object vs symbol.
|
|
(defmethod enemy-method-53 enemy ((obj enemy) (proc-focus process-focusable))
|
|
"TODO"
|
|
(the-as symbol (and proc-focus (!= obj proc-focus) (collide-check? (-> obj focus) proc-focus)))
|
|
)
|
|
|
|
;; definition for method 20 of type enemy
|
|
(defmethod get-trans enemy ((obj enemy) (arg0 int))
|
|
"@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])"
|
|
(let ((s4-0 (-> obj root-override2)))
|
|
(cond
|
|
((zero? arg0)
|
|
(-> s4-0 trans)
|
|
)
|
|
((and (= arg0 1) (type? s4-0 collide-shape-moving))
|
|
(-> s4-0 gspot-pos)
|
|
)
|
|
((= arg0 2)
|
|
(vector<-cspace! (new 'static 'vector) (-> obj node-list data (-> obj enemy-info look-at-joint)))
|
|
)
|
|
((= arg0 3)
|
|
(let ((v0-0 (vector<-cspace! (new 'static 'vector) (-> obj node-list data (-> obj enemy-info bullseye-joint)))))
|
|
(set! (-> v0-0 w) (-> obj root-override2 root-prim prim-core world-sphere w))
|
|
v0-0
|
|
)
|
|
)
|
|
(else
|
|
(-> s4-0 trans)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 124 of type enemy
|
|
(defmethod enemy-method-124 enemy ((obj enemy))
|
|
"TODO"
|
|
(let* ((v1-0 (-> obj enemy-info))
|
|
(v0-0 (if (logtest? (enemy-flag use-trigger) (-> obj enemy-flags))
|
|
(-> v1-0 recover-gnd-collide-with)
|
|
(-> v1-0 gnd-collide-with)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj gnd-collide) (the-as uint v0-0))
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 59 of type enemy
|
|
(defmethod enemy-method-59 enemy ((obj enemy))
|
|
(penetrated-by-all&hit-points->penetrated-by (-> obj penetrated-by-all) (-> obj hit-points))
|
|
)
|
|
|
|
;; definition for method 24 of type enemy
|
|
(defmethod get-water-height enemy ((obj enemy))
|
|
(-> obj water-surface-height)
|
|
)
|
|
|
|
;; definition for method 54 of type enemy
|
|
;; INFO: Used lq/sq
|
|
(defmethod enemy-method-54 enemy ((obj enemy))
|
|
(let ((s4-0 (-> obj root-override2)))
|
|
(when (>= (-> obj water-max-height) (-> s4-0 trans y))
|
|
(let ((s5-0 (new 'stack-no-clear 'water-info)))
|
|
(water-info-init! s4-0 s5-0 (collide-action solid semi-solid))
|
|
(let ((s3-0 (-> s5-0 flags)))
|
|
(when (logtest? (water-flags touch-water) s3-0)
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag directed-ready) (-> obj enemy-flags)))
|
|
(set! (-> obj water-surface-height) (-> s5-0 trans y))
|
|
(when (not (logtest? (-> obj focus-status) (focus-status touch-water under-water)))
|
|
(let ((s2-0 (new 'stack-no-clear 'vector)))
|
|
(set! (-> s2-0 quad) (-> obj root-override2 trans quad))
|
|
(set! (-> s2-0 y) (+ 409.6 (-> s5-0 trans y)))
|
|
(let ((s1-0 (get-process *default-dead-pool* part-tracker #x4000)))
|
|
(when s1-0
|
|
(let ((t9-2 (method-of-type part-tracker activate)))
|
|
(t9-2
|
|
(the-as part-tracker s1-0)
|
|
*entity-pool*
|
|
(symbol->string (-> part-tracker symbol))
|
|
(the-as pointer #x70004000)
|
|
)
|
|
)
|
|
(let ((t9-3 run-function-in-process)
|
|
(a0-8 s1-0)
|
|
(a1-3 part-tracker-init)
|
|
(a2-5 (-> *part-group-id-table* 121))
|
|
(a3-1 0)
|
|
(t0-0 #f)
|
|
(t1-0 #f)
|
|
(t2-0 #f)
|
|
(t3-0 *launch-matrix*)
|
|
)
|
|
(set! (-> t3-0 trans quad) (-> s2-0 quad))
|
|
((the-as (function object object object object object object object object none) t9-3)
|
|
a0-8
|
|
a1-3
|
|
a2-5
|
|
a3-1
|
|
t0-0
|
|
t1-0
|
|
t2-0
|
|
t3-0
|
|
)
|
|
)
|
|
(-> s1-0 ppointer)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((logtest? s3-0 (water-flags dark-eco))
|
|
(sound-play "eco-splash")
|
|
(send-event obj 'instant-death)
|
|
)
|
|
(else
|
|
(sound-play "splash")
|
|
)
|
|
)
|
|
)
|
|
(logior! (-> obj focus-status) (focus-status touch-water))
|
|
(let* ((v1-32 (-> s4-0 root-prim prim-core))
|
|
(f0-5 (+ (-> v1-32 world-sphere y) (-> v1-32 world-sphere w)))
|
|
)
|
|
(if (logtest? (-> obj focus-status) (focus-status under-water))
|
|
(set! f0-5 (+ -819.2 f0-5))
|
|
)
|
|
(if (< f0-5 (-> s5-0 trans y))
|
|
(logior! (-> obj focus-status) (focus-status under-water))
|
|
(logclear! (-> obj focus-status) (focus-status under-water))
|
|
)
|
|
)
|
|
(return (the-as enemy-flag #f))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(logclear! (-> obj focus-status) (focus-status touch-water under-water))
|
|
(when (not (logtest? (enemy-flag use-trigger) (-> obj enemy-flags)))
|
|
(let ((v0-9 (logclear (-> obj enemy-flags) (enemy-flag directed-ready))))
|
|
(set! (-> obj enemy-flags) v0-9)
|
|
v0-9
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 55 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-55 enemy ((obj enemy))
|
|
(with-pp
|
|
(if (and (nonzero? (-> obj draw)) (logtest? (-> obj draw status) (draw-control-status on-screen)))
|
|
(set! (-> obj last-draw-time) (the-as uint (-> pp clock frame-counter)))
|
|
)
|
|
(enemy-method-129 obj)
|
|
(if (logtest? (enemy-flag use-trigger) (-> obj enemy-flags))
|
|
(enemy-method-100 obj)
|
|
)
|
|
(when *target*
|
|
(if *target*
|
|
(look-at!
|
|
(-> *target* neck)
|
|
(the-as vector (-> obj root-override2 root-prim prim-core))
|
|
(if (logtest? (-> obj enemy-flags) (enemy-flag use-notice-distance))
|
|
'attacking
|
|
)
|
|
obj
|
|
)
|
|
)
|
|
)
|
|
(when (nonzero? (-> obj neck))
|
|
(when (logtest? (-> obj enemy-flags) (enemy-flag lock-focus))
|
|
(let ((a0-9 (handle->process (-> obj focus handle))))
|
|
(if a0-9
|
|
(target-set! (-> obj neck) (get-trans (the-as process-focusable a0-9) 2))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (and (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup))
|
|
(>= (- (-> pp clock frame-counter) (the-as int (-> obj auto-reset-penetrate-time))) (seconds 0.1))
|
|
)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag attackable-backup))
|
|
(set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj))
|
|
(let ((v1-48 0))
|
|
(if (logtest? (penetrate knocked) (-> obj root-override2 penetrate-using))
|
|
(set! v1-48 (logior (shl 1 32) v1-48))
|
|
)
|
|
(set! (-> obj root-override2 penetrate-using) (the-as penetrate v1-48))
|
|
)
|
|
)
|
|
(if (logtest? (-> obj enemy-flags) (enemy-flag look-at-focus))
|
|
(enemy-method-136 obj)
|
|
)
|
|
(if (logtest? (enemy-flag trackable-backup directed-ready) (-> obj enemy-flags))
|
|
(enemy-method-54 obj)
|
|
)
|
|
(if (and *debug-segment* (-> obj enemy-info debug-draw-neck) (nonzero? (-> obj neck)))
|
|
(joint-mod-debug-draw (-> obj neck))
|
|
)
|
|
(ja-post)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 136 of type enemy
|
|
(defmethod enemy-method-136 enemy ((obj enemy))
|
|
(with-pp
|
|
(when (or (>= (- (-> pp clock frame-counter) (the-as int (-> obj hit-focus-time))) (seconds 2))
|
|
(and (handle->process (-> obj focus handle))
|
|
(zero? (logand (-> (the-as process-focusable (handle->process (-> obj focus handle))) focus-status)
|
|
(focus-status disable dead ignore grabbed)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((v0-0 (logclear (-> obj enemy-flags) (enemy-flag look-at-focus))))
|
|
(set! (-> obj enemy-flags) v0-0)
|
|
v0-0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function get-penetrate-using-from-attack-event
|
|
;; WARN: Return type mismatch int vs penetrate.
|
|
(defun get-penetrate-using-from-attack-event ((arg0 process-drawable) (arg1 event-message-block))
|
|
(let ((v1-0 (the-as attack-info (-> arg1 param 1))))
|
|
(if (logtest? (attack-info-mask penetrate-using) (-> v1-0 mask))
|
|
(return (the-as penetrate (-> v1-0 penetrate-using)))
|
|
)
|
|
)
|
|
(let* ((gp-0 arg0)
|
|
(v1-3 (if (type? gp-0 process-drawable)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(when v1-3
|
|
(let* ((gp-1 (-> v1-3 root))
|
|
(v1-4 (if (type? gp-1 collide-shape)
|
|
(the-as collide-shape gp-1)
|
|
)
|
|
)
|
|
)
|
|
(if v1-4
|
|
(return (the-as penetrate (logior (-> v1-4 penetrate-using) (penetrate generic-attack))))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(the-as penetrate 2)
|
|
)
|
|
|
|
;; definition for method 107 of type enemy
|
|
;; WARN: Return type mismatch process vs process-focusable.
|
|
(defmethod enemy-method-107 enemy ((obj enemy))
|
|
(let ((v0-0 (handle->process (-> obj focus handle))))
|
|
(if (and v0-0
|
|
(not (and v0-0
|
|
(zero? (logand (-> (the-as process-focusable v0-0) focus-status) (focus-status disable dead ignore grabbed)))
|
|
)
|
|
)
|
|
)
|
|
(set! v0-0 (the-as process #f))
|
|
)
|
|
(the-as process-focusable v0-0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 63 of type enemy
|
|
(defmethod enemy-method-63 enemy ((obj enemy) (arg0 process-focusable) (arg1 symbol))
|
|
(if arg1
|
|
(enemy-focus-method-13 (-> obj focus) arg0 (the-as enemy-aware arg1))
|
|
(try-update-focus (-> obj focus) arg0 obj)
|
|
)
|
|
)
|
|
|
|
;; definition for method 62 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-62 enemy ((obj enemy))
|
|
(when (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
|
|
(let* ((s4-0 (handle->process (-> obj incoming attacker-handle)))
|
|
(s5-0 (if (type? s4-0 process-focusable)
|
|
s4-0
|
|
)
|
|
)
|
|
)
|
|
(when (enemy-method-53 obj (the-as process-focusable s5-0))
|
|
(enemy-method-63 obj (the-as process-focusable s5-0) #f)
|
|
(logior! (-> obj focus flags) (enemy-flag lock-focus))
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 108 of type enemy
|
|
(defmethod enemy-method-108 enemy ((obj enemy) (arg0 enemy) (arg1 event-message-block))
|
|
(let ((s4-0 (the-as touching-shapes-entry (-> arg1 param 0))))
|
|
(when (and s4-0
|
|
(and (logtest? (-> obj incoming penetrate-using) 4096) (zero? (logand (-> obj incoming penetrate-using) 32)))
|
|
(begin
|
|
(let ((s3-0 (-> s4-0 head)))
|
|
(while s3-0
|
|
(let ((s2-0 (get-touched-prim s3-0 (-> arg0 root-override2) s4-0)))
|
|
(get-touched-prim s3-0 (-> obj root-override2) s4-0)
|
|
(when (logtest? (-> s2-0 prim-core action) (collide-action solid semi-solid deadly))
|
|
(let* ((a0-5 obj)
|
|
(t9-2 (method-of-object a0-5 enemy-method-104))
|
|
(a1-3 arg0)
|
|
(a2-3 s4-0)
|
|
(v1-13 *game-info*)
|
|
(a3-1 (+ (-> v1-13 attack-id) 1))
|
|
)
|
|
(set! (-> v1-13 attack-id) a3-1)
|
|
(if (t9-2 a0-5 a1-3 (the-as uint a2-3) a3-1)
|
|
(return 0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! s3-0 (-> s3-0 next))
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
)
|
|
|
|
;; definition for method 64 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod enemy-method-64 enemy ((obj enemy))
|
|
(let ((v1-1 (-> obj root-override2 root-prim)))
|
|
(set! (-> v1-1 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-1 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(logior! (-> obj draw status) (draw-control-status no-draw))
|
|
(logior! (-> obj focus-status) (focus-status disable))
|
|
(go (method-of-object obj dormant))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 65 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod enemy-method-65 enemy ((obj enemy))
|
|
(let ((v1-1 (-> obj root-override2 root-prim)))
|
|
(set! (-> v1-1 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-1 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(logior! (-> obj draw status) (draw-control-status no-draw))
|
|
(logior! (-> obj focus-status) (focus-status disable))
|
|
(go (method-of-object obj dormant-aware))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 67 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod go-stare enemy ((obj enemy))
|
|
(go (method-of-object obj stare))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 68 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod go-stare2 enemy ((obj enemy))
|
|
(go (method-of-object obj stare))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 70 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod go-hostile enemy ((obj enemy))
|
|
(go (method-of-object obj hostile))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 66 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod go-ambush enemy ((obj enemy))
|
|
(go (method-of-object obj ambush))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 71 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod go-flee enemy ((obj enemy))
|
|
(go (method-of-object obj flee))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 69 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod go-directed enemy ((obj enemy))
|
|
(go (method-of-object obj directed))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 72 of type enemy
|
|
(defmethod enemy-method-72 enemy ((obj enemy))
|
|
(let ((s5-0 (-> obj focus aware)))
|
|
(cond
|
|
((and (= s5-0 (enemy-aware enemy-aware-3)) (enemy-method-107 obj))
|
|
(go-hostile obj)
|
|
)
|
|
((<= (the-as int s5-0) 0)
|
|
(go (method-of-object obj idle))
|
|
)
|
|
((>= 1 (the-as int s5-0))
|
|
(go (method-of-object obj active))
|
|
)
|
|
((= s5-0 (enemy-aware enemy-aware-4))
|
|
(go-flee obj)
|
|
)
|
|
(else
|
|
(go-stare obj)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 93 of type enemy
|
|
(defmethod enemy-method-93 enemy ((obj enemy))
|
|
(if (logtest? (enemy-flag alert) (-> obj enemy-flags))
|
|
(go-directed obj)
|
|
(enemy-method-72 obj)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 73 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod enemy-method-73 enemy ((obj enemy))
|
|
(if (-> obj enemy-info use-die-falling)
|
|
(go (method-of-object obj die-falling))
|
|
(go (method-of-object obj die))
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 135 of type enemy
|
|
;; INFO: Used lq/sq
|
|
(defmethod enemy-method-135 enemy ((obj enemy) (arg0 int))
|
|
(let ((gp-0 (make-u128 0 0)))
|
|
(let ((v1-0 arg0))
|
|
(cond
|
|
((zero? v1-0)
|
|
(set! gp-0 (the-as uint (-> obj enemy-info sound-hit)))
|
|
)
|
|
((= v1-0 1)
|
|
(set! gp-0 (the-as uint (-> obj enemy-info sound-die)))
|
|
)
|
|
)
|
|
)
|
|
(if (nonzero? gp-0)
|
|
(sound-play-by-name (the-as sound-name gp-0) (new-sound-id) 1024 0 0 (sound-group sfx) #t)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 94 of type enemy
|
|
;; INFO: Used lq/sq
|
|
(defmethod enemy-method-94 enemy ((obj enemy) (arg0 vector) (arg1 float))
|
|
(let ((s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat)))
|
|
(s5-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
(set! (-> s5-0 quad) (-> arg0 quad))
|
|
(set! (-> s4-0 y) 0.0)
|
|
(vector-normalize! s4-0 1.0)
|
|
(set! (-> s5-0 y) 0.0)
|
|
(vector-normalize! s5-0 1.0)
|
|
(>= (vector-dot s4-0 s5-0) (cos arg1))
|
|
)
|
|
)
|
|
|
|
;; definition for method 95 of type enemy
|
|
(defmethod enemy-method-95 enemy ((obj enemy) (arg0 vector) (arg1 float))
|
|
(let ((v1-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj root-override2 trans))))
|
|
(enemy-method-94 obj v1-1 arg1)
|
|
)
|
|
)
|
|
|
|
;; definition for method 96 of type enemy
|
|
(defmethod enemy-method-96 enemy ((obj enemy) (arg0 float) (arg1 symbol))
|
|
(let ((a0-2 (handle->process (-> obj focus handle))))
|
|
(cond
|
|
(a0-2
|
|
(let ((s4-1 (vector-!
|
|
(new 'stack-no-clear 'vector)
|
|
(get-trans (the-as process-focusable a0-2) 0)
|
|
(-> obj root-override2 trans)
|
|
)
|
|
)
|
|
)
|
|
(enemy-method-94 obj s4-1 arg0)
|
|
)
|
|
)
|
|
(else
|
|
arg1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 104 of type enemy
|
|
(defmethod enemy-method-104 enemy ((obj enemy) (arg0 process) (arg1 uint) (arg2 uint))
|
|
(let ((v1-1 (-> obj enemy-info attack-damage)))
|
|
(if (and (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) (= v1-1 1))
|
|
(set! v1-1 2)
|
|
)
|
|
(let ((a1-2 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> a1-2 from) (process->ppointer self))
|
|
(set! (-> a1-2 num-params) 2)
|
|
(set! (-> a1-2 message) 'attack)
|
|
(set! (-> a1-2 param 0) arg1)
|
|
(let ((a0-10 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id damage knock))))
|
|
(set! (-> a0-10 id) arg2)
|
|
(set! (-> a0-10 shove-back) (-> obj enemy-info attack-shove-back))
|
|
(set! (-> a0-10 shove-up) (-> obj enemy-info attack-shove-up))
|
|
(set! (-> a0-10 mode) (-> obj enemy-info attack-mode))
|
|
(set! (-> a0-10 damage) (the float v1-1))
|
|
(set! (-> a0-10 knock) (the-as uint 8))
|
|
(set! (-> a1-2 param 1) (the-as uint a0-10))
|
|
)
|
|
(when (send-event-function arg0 a1-2)
|
|
(enemy-method-105 obj arg0)
|
|
#t
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 105 of type enemy
|
|
(defmethod enemy-method-105 enemy ((obj enemy) (arg0 process))
|
|
(with-pp
|
|
(when (logtest? (process-mask target bot) (-> arg0 mask))
|
|
(set! (-> obj root-override2 penetrated-by) (the-as penetrate -1))
|
|
(enemy-method-49 obj)
|
|
)
|
|
(let ((s5-0 (if (type? arg0 process-focusable)
|
|
arg0
|
|
)
|
|
)
|
|
)
|
|
(when (enemy-method-53 obj (the-as process-focusable s5-0))
|
|
(let ((v1-10 (handle->process (-> obj focus handle))))
|
|
(when (or (= s5-0 v1-10) (and (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
|
|
(or (not v1-10) (zero? (logand (-> obj focus flags) (enemy-flag lock-focus))))
|
|
)
|
|
)
|
|
(enemy-method-63 obj (the-as process-focusable s5-0) #f)
|
|
(set! (-> obj hit-focus-time) (the-as uint (-> pp clock frame-counter)))
|
|
(let ((v0-3 (logior (-> obj enemy-flags) (enemy-flag look-at-focus))))
|
|
(set! (-> obj enemy-flags) v0-3)
|
|
v0-3
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 49 of type enemy
|
|
(defmethod enemy-method-49 enemy ((obj enemy))
|
|
(logior! (-> obj enemy-flags) (enemy-flag attackable-backup))
|
|
(let ((v0-0 (-> self clock frame-counter)))
|
|
(set! (-> obj auto-reset-penetrate-time) (the-as uint v0-0))
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 50 of type enemy
|
|
;; INFO: Used lq/sq
|
|
(defmethod enemy-method-50 enemy ((obj enemy) (arg0 vector))
|
|
(set! (-> arg0 quad) (-> obj incoming attack-direction quad))
|
|
(let ((v1-1 arg0))
|
|
(when (= (+ (* (-> v1-1 x) (-> v1-1 x)) (* (-> v1-1 z) (-> v1-1 z))) 0.0)
|
|
(vector-z-quaternion! arg0 (-> obj root-override2 quat))
|
|
(vector-negate-in-place! arg0)
|
|
)
|
|
)
|
|
(set! (-> arg0 y) 0.0)
|
|
(vector-xz-normalize! arg0 1.0)
|
|
)
|
|
|
|
;; definition for method 131 of type enemy
|
|
;; WARN: Return type mismatch int vs uint.
|
|
(defmethod enemy-method-131 enemy ((obj enemy) (arg0 int))
|
|
(the-as uint (cond
|
|
((logtest? arg0 1024)
|
|
7
|
|
)
|
|
((logtest? #x1000000 arg0)
|
|
6
|
|
)
|
|
((logtest? #x4400000 arg0)
|
|
4
|
|
)
|
|
((logtest? #x800000 arg0)
|
|
5
|
|
)
|
|
((logtest? #xc0000 arg0)
|
|
3
|
|
)
|
|
((logtest? #xa200000 arg0)
|
|
2
|
|
)
|
|
((logtest? arg0 #x4000)
|
|
1
|
|
)
|
|
(else
|
|
0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 106 of type enemy
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-106 enemy ((obj enemy) (arg0 process) (arg1 object) (arg2 int) (arg3 attack-info))
|
|
(set! (-> obj incoming penetrate-using) (the-as uint arg2))
|
|
(set! (-> obj incoming attack-id) (-> arg3 id))
|
|
(let ((v1-3 (if (logtest? (attack-info-mask knock) (-> arg3 mask))
|
|
(-> arg3 knock)
|
|
(enemy-method-131 obj arg2)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj incoming knocked-type) (the-as knocked-type v1-3))
|
|
(let ((a0-4 (-> self clock frame-counter)))
|
|
(cond
|
|
((!= v1-3 6)
|
|
(set! (-> obj incoming blue-juggle-count) (the-as uint 0))
|
|
0
|
|
)
|
|
((>= (- (-> self clock frame-counter) (-> obj incoming attack-time)) (seconds 1))
|
|
(set! (-> obj incoming blue-juggle-count) (the-as uint 1))
|
|
)
|
|
(else
|
|
(+! (-> obj incoming blue-juggle-count) 1)
|
|
)
|
|
)
|
|
(set! (-> obj incoming attack-time) a0-4)
|
|
)
|
|
(cond
|
|
((= v1-3 7)
|
|
(set! (-> obj incoming attack-direction quad) (-> arg3 vector quad))
|
|
)
|
|
(else
|
|
(let ((s3-0 (new 'stack-no-clear 'attack-info)))
|
|
(attack-info-method-9 arg3 s3-0 (the-as process-drawable arg0) obj)
|
|
(set! (-> obj incoming attacker-pos quad) (-> s3-0 intersection quad))
|
|
(set! (-> obj incoming attack-direction quad) (-> s3-0 attacker-velocity quad))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj incoming attacker-handle) (process->handle (enemy-method-134 obj arg0 arg3)))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 109 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-109 enemy ((obj enemy) (arg0 int))
|
|
(case arg0
|
|
((1)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag death-start))
|
|
(logior! (-> obj enemy-flags) (enemy-flag lock-focus))
|
|
)
|
|
((2)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag lock-focus))
|
|
(logior! (-> obj enemy-flags) (enemy-flag death-start))
|
|
)
|
|
)
|
|
(if (nonzero? (-> obj neck))
|
|
(mode-set! (-> obj neck) (joint-mod-mode look-at))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 110 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-110 enemy ((obj enemy))
|
|
(when (nonzero? (-> obj neck))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag lock-focus death-start))
|
|
(shut-down (-> obj neck))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 125 of type enemy
|
|
(defmethod enemy-method-125 enemy ((obj enemy) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float))
|
|
(when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4)
|
|
(let ((v0-1 (-> arg0 best-other-tri pat)))
|
|
(set! (-> obj root-override2 ground-pat) v0-1)
|
|
v0-1
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 126 of type enemy
|
|
(defmethod enemy-method-126 enemy ((obj enemy) (arg0 collide-query) (arg1 vector) (arg2 collide-spec) (arg3 float) (arg4 float) (arg5 float))
|
|
(above-ground? (-> obj root-override2) arg0 arg1 arg2 arg3 arg4 arg5)
|
|
)
|
|
|
|
;; definition for method 127 of type enemy
|
|
;; INFO: Used lq/sq
|
|
(defmethod enemy-method-127 enemy ((obj enemy) (arg0 float) (arg1 float) (arg2 symbol) (arg3 collide-spec))
|
|
(let ((s4-0 (new 'stack-no-clear 'collide-query)))
|
|
(cond
|
|
((enemy-method-125 obj s4-0 arg3 arg0 arg1 1024.0)
|
|
(let ((s5-1 (-> obj root-override2)))
|
|
(let ((s3-0 (new 'stack-no-clear 'vector)))
|
|
(set! (-> s3-0 quad) (-> obj root-override2 trans quad))
|
|
(set! (-> s3-0 y) (-> s4-0 best-other-tri intersect y))
|
|
(move-to-point! s5-1 s3-0)
|
|
(let ((a0-3 (-> s4-0 best-other-tri normal))
|
|
(v1-8 (-> s4-0 best-other-tri pat))
|
|
)
|
|
(set! (-> s5-1 grount-touch-point quad) (-> s3-0 quad))
|
|
(set! (-> s5-1 poly-normal quad) (-> a0-3 quad))
|
|
(set! (-> s5-1 surface-normal quad) (-> a0-3 quad))
|
|
(set! (-> s5-1 local-normal quad) (-> a0-3 quad))
|
|
(set! (-> s5-1 ground-poly-normal quad) (-> a0-3 quad))
|
|
(set! (-> s5-1 poly-pat) v1-8)
|
|
(set! (-> s5-1 cur-pat) v1-8)
|
|
(set! (-> s5-1 ground-pat) v1-8)
|
|
)
|
|
)
|
|
(logior! (-> s5-1 status) (collide-status on-surface on-ground touch-surface))
|
|
)
|
|
#t
|
|
)
|
|
(else
|
|
(let ((v1-11 (-> obj root-override2)))
|
|
(logclear! (-> v1-11 status) (collide-status
|
|
on-surface
|
|
on-ground
|
|
touch-surface
|
|
touch-wall
|
|
touch-ceiling
|
|
touch-actor
|
|
on-special-surface
|
|
touch-edge
|
|
blocked
|
|
on-water
|
|
impact-surface
|
|
touch-background
|
|
stuck
|
|
glance
|
|
)
|
|
)
|
|
(when (not (logtest? (-> v1-11 root-prim prim-core action) (collide-action no-normal-reset)))
|
|
(let ((a0-12 (-> v1-11 dynam gravity-normal)))
|
|
(set! (-> v1-11 local-normal quad) (-> a0-12 quad))
|
|
(set! (-> v1-11 surface-normal quad) (-> a0-12 quad))
|
|
(set! (-> v1-11 poly-normal quad) (-> a0-12 quad))
|
|
)
|
|
(set! (-> v1-11 coverage) 0.0)
|
|
(set! (-> v1-11 touch-angle) 0.0)
|
|
)
|
|
)
|
|
(if arg2
|
|
(format 0 "WARNING: enemy::move-to-ground: failed to locate ground for ~S!~%" (-> obj name))
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 128 of type enemy
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-128 enemy ((obj enemy) (arg0 vector) (arg1 move-above-ground-params))
|
|
(let ((gp-0 (-> obj root-override2)))
|
|
(set! (-> arg1 on-ground?) #f)
|
|
(set! (-> arg1 do-move?) #t)
|
|
(set! (-> arg1 old-gspot-pos quad) (-> gp-0 gspot-pos quad))
|
|
(set! (-> arg1 old-gspot-normal quad) (-> gp-0 gspot-normal quad))
|
|
(set! (-> gp-0 trans-old-old-old quad) (-> gp-0 trans-old-old quad))
|
|
(set! (-> gp-0 trans-old-old quad) (-> gp-0 trans-old quad))
|
|
(set! (-> gp-0 trans-old quad) (-> gp-0 trans quad))
|
|
(set! (-> gp-0 prev-status) (-> gp-0 status))
|
|
(vector-v+! (-> gp-0 trans) (-> gp-0 trans) arg0)
|
|
(set! (-> arg1 new-pos quad) (-> gp-0 trans quad))
|
|
(let ((s2-0 (new 'stack-no-clear 'collide-query)))
|
|
(cond
|
|
((enemy-method-125 obj s2-0 (-> arg1 gnd-collide-with) (-> arg1 popup) 81920.0 1024.0)
|
|
(when (>= (-> gp-0 gspot-pos y) (-> arg1 new-pos y))
|
|
(set! (-> arg1 on-ground?) #t)
|
|
(set! (-> arg1 pat) (-> s2-0 best-other-tri pat))
|
|
(set! (-> arg1 new-pos y) (-> s2-0 best-other-tri intersect y))
|
|
(set! (-> gp-0 ground-impact-vel) (- (vector-dot arg0 (-> gp-0 dynam gravity-normal))))
|
|
(set! (-> arg0 y) 0.0)
|
|
)
|
|
)
|
|
(else
|
|
(if (-> arg1 hover-if-no-ground?)
|
|
(set! (-> arg1 new-pos y) (-> gp-0 trans-old y))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> gp-0 trans quad) (-> gp-0 trans-old quad))
|
|
(move-to-point! gp-0 (-> arg1 new-pos))
|
|
(when (logtest? (logand (-> arg1 overlaps-params collide-with-filter)
|
|
(collide-spec hit-by-player-list hit-by-others-list player-list)
|
|
)
|
|
(-> gp-0 root-prim prim-core collide-with)
|
|
)
|
|
(when (find-overlapping-shapes gp-0 (-> arg1 overlaps-params))
|
|
(when (-> arg1 dont-move-if-overlaps?)
|
|
(set! (-> arg1 do-move?) #f)
|
|
(move-to-point! gp-0 (-> gp-0 trans-old))
|
|
(set! (-> gp-0 gspot-pos quad) (-> arg1 old-gspot-pos quad))
|
|
(set! (-> gp-0 gspot-normal quad) (-> arg1 old-gspot-normal quad))
|
|
)
|
|
)
|
|
)
|
|
(when (-> arg1 do-move?)
|
|
(cond
|
|
((-> arg1 on-ground?)
|
|
(let ((a1-6 (-> gp-0 gspot-pos))
|
|
(a0-21 (-> gp-0 gspot-normal))
|
|
(v1-39 (-> arg1 pat))
|
|
)
|
|
(set! (-> gp-0 grount-touch-point quad) (-> a1-6 quad))
|
|
(set! (-> gp-0 poly-normal quad) (-> a0-21 quad))
|
|
(set! (-> gp-0 surface-normal quad) (-> a0-21 quad))
|
|
(set! (-> gp-0 local-normal quad) (-> a0-21 quad))
|
|
(set! (-> gp-0 ground-poly-normal quad) (-> a0-21 quad))
|
|
(set! (-> gp-0 poly-pat) v1-39)
|
|
(set! (-> gp-0 cur-pat) v1-39)
|
|
(set! (-> gp-0 ground-pat) v1-39)
|
|
)
|
|
(logior! (-> gp-0 status) (collide-status on-surface on-ground touch-surface))
|
|
)
|
|
(else
|
|
(logclear! (-> gp-0 status) (collide-status
|
|
on-surface
|
|
on-ground
|
|
touch-surface
|
|
touch-wall
|
|
touch-ceiling
|
|
touch-actor
|
|
on-special-surface
|
|
touch-edge
|
|
blocked
|
|
on-water
|
|
impact-surface
|
|
touch-background
|
|
stuck
|
|
glance
|
|
)
|
|
)
|
|
(when (not (logtest? (-> gp-0 root-prim prim-core action) (collide-action no-normal-reset)))
|
|
(let ((v1-49 (-> gp-0 dynam gravity-normal)))
|
|
(set! (-> gp-0 local-normal quad) (-> v1-49 quad))
|
|
(set! (-> gp-0 surface-normal quad) (-> v1-49 quad))
|
|
(set! (-> gp-0 poly-normal quad) (-> v1-49 quad))
|
|
)
|
|
(set! (-> gp-0 coverage) 0.0)
|
|
(set! (-> gp-0 touch-angle) 0.0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 111 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-111 enemy ((obj enemy))
|
|
(let ((v1-0 (-> obj root-override2)))
|
|
(when (logtest? (-> v1-0 status) (collide-status touch-surface))
|
|
(let ((f0-1 (fmax 0.0 (+ 1.0 (* 60.0 (-> self clock seconds-per-frame) (+ -1.0 (-> obj enemy-info friction)))))))
|
|
(vector-float*! (-> v1-0 transv) (-> v1-0 transv) f0-1)
|
|
)
|
|
0
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 114 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-114 enemy ((obj enemy))
|
|
"@abstract"
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 115 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-115 enemy ((obj enemy))
|
|
"@abstract"
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 116 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod go-idle enemy ((obj enemy))
|
|
(go (method-of-object obj idle))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 112 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-112 enemy ((obj enemy) (arg0 enemy-info))
|
|
(set! (-> obj enemy-info) arg0)
|
|
(when (and (!= (-> obj enemy-info neck-joint) -1) (zero? (-> obj neck)))
|
|
(set! (-> obj neck) (new 'process 'joint-mod (joint-mod-mode flex-blend) obj (-> obj enemy-info neck-joint)))
|
|
(set-vector! (-> obj neck twist-max) 8192.0 8192.0 0.0 1.0)
|
|
(set! (-> obj neck up) (the-as uint 1))
|
|
(set! (-> obj neck nose) (the-as uint 2))
|
|
(set! (-> obj neck ear) (the-as uint 0))
|
|
(set! (-> obj neck max-dist) 102400.0)
|
|
(set! (-> obj neck ignore-angle) 16384.0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 113 of type enemy
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-113 enemy ((obj enemy) (arg0 enemy-info))
|
|
(local-vars (sv-16 res-tag))
|
|
(when (coin-flip? obj)
|
|
(let ((a0-2 (-> obj node-list data 2)))
|
|
(set! (-> a0-2 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint-flip-z!))
|
|
(set! (-> a0-2 param1) #f)
|
|
(set! (-> a0-2 param2) #f)
|
|
)
|
|
(set! (-> obj enemy-flags) (the-as enemy-flag (logior (enemy-flag dislike-combo) (-> obj enemy-flags))))
|
|
)
|
|
(set! (-> obj mask) (logior (process-mask enemy) (-> obj mask)))
|
|
(logior! (-> obj mask) (process-mask actor-pause))
|
|
(logior! (-> obj enemy-flags) (enemy-flag notice))
|
|
(enemy-method-112 obj arg0)
|
|
(let ((a1-2 (-> obj enemy-info idle-anim-script)))
|
|
(if a1-2
|
|
(idle-control-method-9 (-> obj idle-anim-player) a1-2)
|
|
)
|
|
)
|
|
(if (-> obj draw shadow)
|
|
(set! (-> obj draw shadow-ctrl) (new
|
|
'process
|
|
'shadow-control
|
|
(-> obj enemy-info shadow-min-y)
|
|
(-> obj enemy-info shadow-max-y)
|
|
(-> obj enemy-info shadow-locus-dist)
|
|
(shadow-flags shdf00 shdf04)
|
|
245760.0
|
|
)
|
|
)
|
|
(set! (-> obj draw shadow-ctrl) *enemy-dummy-shadow-control*)
|
|
)
|
|
(set! (-> obj water-max-height) 8192.0)
|
|
(if (logtest? (-> *game-info* secrets) (game-secrets hero-mode))
|
|
(set! (-> obj hit-points) (* (-> obj enemy-info default-hit-points) 2))
|
|
(set! (-> obj hit-points) (-> obj enemy-info default-hit-points))
|
|
)
|
|
(let* ((v1-38 *game-info*)
|
|
(a0-10 (+ (-> v1-38 attack-id) 1))
|
|
)
|
|
(set! (-> v1-38 attack-id) a0-10)
|
|
(set! (-> obj attack-id) a0-10)
|
|
)
|
|
(let* ((v1-39 *game-info*)
|
|
(a0-12 (+ (-> v1-39 attack-id) 1))
|
|
)
|
|
(set! (-> v1-39 attack-id) a0-12)
|
|
(set! (-> obj persistent-attack-id) a0-12)
|
|
)
|
|
(set! (-> obj incoming attacker-handle) (the-as handle #f))
|
|
(enemy-method-124 obj)
|
|
(set! (-> obj fact-info-override) (new
|
|
'process
|
|
'fact-info-enemy
|
|
obj
|
|
(the-as (pointer float) (-> arg0 fact-defaults))
|
|
(pickup-type eco-pill-random)
|
|
(-> *FACT-bank* default-eco-pill-green-inc)
|
|
)
|
|
)
|
|
(let ((a1-5 (if (logtest? (enemy-option multi-focus) (-> obj fact-info-override enemy-options))
|
|
#x400406
|
|
#x400402
|
|
)
|
|
)
|
|
)
|
|
(reset-to-collide-spec (-> obj focus) (the-as collide-spec a1-5))
|
|
)
|
|
(set! sv-16 (new 'static 'res-tag))
|
|
(let ((v1-49 (res-lump-data (-> obj entity) 'actor-groups pointer :tag-ptr (& sv-16))))
|
|
(cond
|
|
((and v1-49 (nonzero? (-> sv-16 elt-count)))
|
|
(set! (-> obj actor-group) (the-as (pointer actor-group) v1-49))
|
|
(set! (-> obj actor-group-count) (the-as int (-> sv-16 elt-count)))
|
|
)
|
|
(else
|
|
(set! (-> obj actor-group) (the-as (pointer actor-group) #f))
|
|
(set! (-> obj actor-group-count) 0)
|
|
0
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj on-notice) (res-lump-struct (-> obj entity) 'on-notice symbol))
|
|
(set! (-> obj on-active) (res-lump-struct (-> obj entity) 'on-active symbol))
|
|
(set! (-> obj on-hostile) (res-lump-struct (-> obj entity) 'on-hostile symbol))
|
|
(set! (-> obj on-death) (res-lump-struct (-> obj entity) 'on-death symbol))
|
|
(if (-> obj on-notice)
|
|
(logior! (-> obj enemy-flags) (enemy-flag auto-reset-penetrate))
|
|
)
|
|
(if (-> obj on-active)
|
|
(logior! (-> obj enemy-flags) (enemy-flag jump-check-blocked))
|
|
)
|
|
(if (-> obj on-hostile)
|
|
(logior! (-> obj enemy-flags) (enemy-flag drawn-mirrored))
|
|
)
|
|
(let ((s4-0 (-> obj root-override2)))
|
|
(set! (-> obj penetrated-by-all) (-> s4-0 penetrated-by))
|
|
(set! (-> s4-0 penetrated-by) (enemy-method-59 obj))
|
|
(set! (-> s4-0 event-self) 'touched)
|
|
)
|
|
(set! (-> obj penetrated-flinch) (the-as penetrate (-> arg0 penetrate-flinch)))
|
|
(set! (-> obj penetrated-knocked) (the-as penetrate (-> arg0 penetrate-knocked)))
|
|
(set! (-> obj reaction-time) (the-as uint (get-rand-int-range obj 30 180)))
|
|
(let* ((v1-79 (-> obj enemy-flags))
|
|
(a0-28 (-> obj fact-info-override enemy-options))
|
|
(v1-80 (logior (enemy-flag
|
|
enable-on-active
|
|
checking-water
|
|
enable-on-notice
|
|
look-at-move-dest
|
|
check-water-backup
|
|
no-initial-move-to-ground
|
|
)
|
|
v1-79
|
|
)
|
|
)
|
|
)
|
|
(if (logtest? (enemy-option multi-focus) a0-28)
|
|
(set! v1-80 (logior (enemy-flag trackable) v1-80))
|
|
)
|
|
(if (logtest? (enemy-option has-trigger) a0-28)
|
|
(set! v1-80 (logior (enemy-flag called-dying) v1-80))
|
|
)
|
|
(set! (-> obj enemy-flags) v1-80)
|
|
)
|
|
(set! (-> obj mask) (logior (process-mask collectable) (-> obj mask)))
|
|
(if (and (-> obj enemy-info move-to-ground)
|
|
(not (logtest? (enemy-flag vulnerable-backup) (-> obj enemy-flags)))
|
|
(zero? (logand (enemy-option ambush) (-> obj fact-info-override enemy-options)))
|
|
)
|
|
(enemy-method-127 obj 40960.0 40960.0 #t (the-as collide-spec (-> obj gnd-collide)))
|
|
)
|
|
(if (zero? (-> obj draw light-index))
|
|
(set! (-> obj draw light-index) (the-as uint 10))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function enemy-init-by-other
|
|
;; INFO: Used lq/sq
|
|
(defbehavior enemy-init-by-other enemy ((arg0 process-drawable) (arg1 transformq))
|
|
(let ((a1-1 (-> arg1 scale x)))
|
|
(if a1-1
|
|
(process-entity-set! self (the-as entity-actor a1-1))
|
|
)
|
|
)
|
|
(if (-> arg1 scale y)
|
|
(set! (-> self enemy-flags) (logior (enemy-flag alert) (-> self enemy-flags)))
|
|
)
|
|
(if (-> arg1 scale z)
|
|
(set! (-> self enemy-flags) (the-as enemy-flag (logior (enemy-flag vulnerable-backup) (-> self enemy-flags))))
|
|
)
|
|
(enemy-method-114 self)
|
|
(set! (-> self root-override2 trans quad) (-> arg1 trans quad))
|
|
(quaternion-copy! (-> self root-override2 quat) (-> arg1 quat))
|
|
(vector-identity! (-> self root-override2 scale))
|
|
(enemy-method-115 self)
|
|
(when (> (-> self enemy-info gem-joint) 0)
|
|
(cond
|
|
((and (or (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status save)))
|
|
(not (-> self entity))
|
|
)
|
|
(not (or (task-node-closed? (game-task-node city-win-introduction))
|
|
(logtest? (-> *game-info* secrets) (game-secrets hero-mode))
|
|
)
|
|
)
|
|
)
|
|
(setup-masks
|
|
(-> self draw)
|
|
(the-as int (-> self enemy-info gem-no-seg))
|
|
(the-as int (-> self enemy-info gem-seg))
|
|
)
|
|
)
|
|
(else
|
|
(setup-masks
|
|
(-> self draw)
|
|
(the-as int (-> self enemy-info gem-seg))
|
|
(the-as int (-> self enemy-info gem-no-seg))
|
|
)
|
|
(add-connection *part-engine* self (-> self enemy-info gem-joint) self 314 (-> self enemy-info gem-offset))
|
|
)
|
|
)
|
|
)
|
|
(let ((v1-43 (-> self fact-info-override enemy-options)))
|
|
(cond
|
|
(*debug-view-anims*
|
|
(go-virtual view-anims)
|
|
)
|
|
((logtest? (enemy-option dormant) v1-43)
|
|
(enemy-method-64 self)
|
|
)
|
|
((logtest? (enemy-flag alert) (-> self enemy-flags))
|
|
(go-directed self)
|
|
)
|
|
((logtest? (enemy-option dormant-aware) v1-43)
|
|
(enemy-method-65 self)
|
|
)
|
|
((logtest? (enemy-option ambush) (-> self fact-info-override enemy-options))
|
|
(go-ambush self)
|
|
)
|
|
(else
|
|
(go-idle self)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 11 of type enemy
|
|
(defmethod init-from-entity! enemy ((obj enemy) (arg0 entity-actor))
|
|
(enemy-method-114 obj)
|
|
(process-drawable-from-entity! obj arg0)
|
|
(enemy-method-115 obj)
|
|
(when (>= (-> obj enemy-info gem-joint) 0)
|
|
(cond
|
|
((and (or (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status save)))
|
|
(not (-> obj entity))
|
|
)
|
|
(not (or (task-node-closed? (game-task-node city-win-introduction))
|
|
(logtest? (-> *game-info* secrets) (game-secrets hero-mode))
|
|
)
|
|
)
|
|
)
|
|
(setup-masks
|
|
(-> obj draw)
|
|
(the-as int (-> obj enemy-info gem-no-seg))
|
|
(the-as int (-> obj enemy-info gem-seg))
|
|
)
|
|
)
|
|
(else
|
|
(setup-masks
|
|
(-> obj draw)
|
|
(the-as int (-> obj enemy-info gem-seg))
|
|
(the-as int (-> obj enemy-info gem-no-seg))
|
|
)
|
|
(add-connection *part-engine* obj (-> obj enemy-info gem-joint) obj 314 (-> obj enemy-info gem-offset))
|
|
)
|
|
)
|
|
)
|
|
(let ((v1-28 (-> obj fact-info-override enemy-options)))
|
|
(cond
|
|
((logtest? (enemy-option spawner) v1-28)
|
|
(process-entity-status! obj (entity-perm-status dead) #t)
|
|
(go (method-of-object obj die-fast))
|
|
)
|
|
(*debug-view-anims*
|
|
(go (method-of-object obj view-anims))
|
|
)
|
|
((logtest? (enemy-option dormant) v1-28)
|
|
(enemy-method-64 obj)
|
|
)
|
|
((logtest? (enemy-option dormant-aware) v1-28)
|
|
(enemy-method-65 obj)
|
|
)
|
|
(else
|
|
(go-idle obj)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 98 of type enemy
|
|
(defmethod enemy-method-98 enemy ((obj enemy) (arg0 process-focusable) (arg1 vector))
|
|
#t
|
|
)
|
|
|
|
;; definition for method 99 of type enemy
|
|
(defmethod enemy-method-99 enemy ((obj enemy) (arg0 process-focusable))
|
|
#f
|
|
)
|
|
|
|
;; definition for method 11 of type enemy-focus
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod reset-to-collide-spec enemy-focus ((obj enemy-focus) (arg0 collide-spec))
|
|
(let ((t9-0 (method-of-type focus reset-to-collide-spec)))
|
|
(t9-0 obj arg0)
|
|
)
|
|
(set! (-> obj aware) (enemy-aware enemy-aware-0))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 129 of type enemy
|
|
;; WARN: Return type mismatch process vs none.
|
|
;; WARN: Function (method 129 enemy) has a return type of none, but the expression builder found a return statement.
|
|
(defmethod enemy-method-129 enemy ((obj enemy))
|
|
(let ((gp-0 (-> obj focus)))
|
|
(let ((a1-0 (handle->process (-> gp-0 handle))))
|
|
(when a1-0
|
|
(let ((v1-4 (-> obj enemy-flags)))
|
|
(cond
|
|
((and a1-0 (zero? (logand (-> (the-as process-focusable a1-0) focus-status) (focus-status disable dead))))
|
|
(when (and (logtest? (enemy-flag trackable) v1-4)
|
|
(not (logtest? (enemy-flag actor-pause-backup) v1-4))
|
|
(zero? (logand (-> gp-0 flags) (enemy-flag lock-focus)))
|
|
)
|
|
(enemy-method-97 obj)
|
|
(return #f)
|
|
)
|
|
(let ((v1-14 (enemy-method-61
|
|
obj
|
|
(the-as int (enemy-method-57 obj (the-as process-focusable a1-0) (the-as enemy-best-focus #f)))
|
|
)
|
|
)
|
|
)
|
|
(set! (-> gp-0 aware) (the-as enemy-aware v1-14))
|
|
(if (>= 1 v1-14)
|
|
(logclear! (-> gp-0 flags) (enemy-flag lock-focus))
|
|
)
|
|
)
|
|
(return #f)
|
|
)
|
|
(else
|
|
(clear-focused gp-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(if (!= (-> gp-0 handle) #f)
|
|
(clear-focused gp-0)
|
|
)
|
|
)
|
|
(if (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
|
|
(enemy-method-97 obj)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 97 of type enemy
|
|
(defmethod enemy-method-97 enemy ((obj enemy))
|
|
(let ((s4-0 (-> obj focus collide-with))
|
|
(gp-0 (new 'stack-no-clear 'enemy-best-focus))
|
|
)
|
|
(set! (-> gp-0 proc) #f)
|
|
(set! (-> gp-0 rating) 409600000.0)
|
|
(set! (-> gp-0 aware) (enemy-aware enemy-aware-0))
|
|
(when (logtest? s4-0 (collide-spec player-list))
|
|
(let ((v1-4 (-> *collide-player-list* alive-list next0)))
|
|
*collide-player-list*
|
|
(let ((s3-0 (-> v1-4 next0)))
|
|
(while (!= v1-4 (-> *collide-player-list* alive-list-end))
|
|
(let ((v1-5 (the-as collide-shape (-> (the-as connection v1-4) param1))))
|
|
(when (logtest? s4-0 (-> v1-5 root-prim prim-core collide-as))
|
|
(let* ((s2-0 (-> v1-5 process))
|
|
(a1-1 (if (type? s2-0 process-focusable)
|
|
(the-as process-focusable s2-0)
|
|
)
|
|
)
|
|
)
|
|
(if (and a1-1 (and a1-1 (zero? (logand (-> a1-1 focus-status) (focus-status disable dead)))) (!= obj a1-1))
|
|
(enemy-method-57 obj a1-1 gp-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! v1-4 s3-0)
|
|
*collide-player-list*
|
|
(set! s3-0 (-> s3-0 next0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (logtest? s4-0 (collide-spec hit-by-player-list hit-by-others-list))
|
|
(when (logtest? s4-0 (collide-spec hit-by-player-list))
|
|
(let ((v1-19 (-> *collide-hit-by-player-list* alive-list next0)))
|
|
*collide-hit-by-player-list*
|
|
(let ((s3-1 (-> v1-19 next0)))
|
|
(while (!= v1-19 (-> *collide-hit-by-player-list* alive-list-end))
|
|
(let ((v1-20 (the-as collide-shape (-> (the-as connection v1-19) param1))))
|
|
(when (logtest? s4-0 (-> v1-20 root-prim prim-core collide-as))
|
|
(let* ((s2-1 (-> v1-20 process))
|
|
(a1-3 (if (type? s2-1 process-focusable)
|
|
(the-as process-focusable s2-1)
|
|
)
|
|
)
|
|
)
|
|
(if (and a1-3 (and a1-3 (zero? (logand (-> a1-3 focus-status) (focus-status disable dead)))) (!= obj a1-3))
|
|
(enemy-method-57 obj a1-3 gp-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! v1-19 s3-1)
|
|
*collide-hit-by-player-list*
|
|
(set! s3-1 (-> s3-1 next0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (logtest? s4-0 (collide-spec hit-by-others-list))
|
|
(let ((v1-32 (-> *collide-hit-by-others-list* alive-list next0)))
|
|
*collide-hit-by-others-list*
|
|
(let ((s3-2 (-> v1-32 next0)))
|
|
(while (!= v1-32 (-> *collide-hit-by-others-list* alive-list-end))
|
|
(let ((v1-33 (the-as collide-shape (-> (the-as connection v1-32) param1))))
|
|
(when (logtest? s4-0 (-> v1-33 root-prim prim-core collide-as))
|
|
(let* ((s2-2 (-> v1-33 process))
|
|
(a1-5 (if (type? s2-2 process-focusable)
|
|
(the-as process-focusable s2-2)
|
|
)
|
|
)
|
|
)
|
|
(if (and a1-5 (and a1-5 (zero? (logand (-> a1-5 focus-status) (focus-status disable dead)))) (!= obj a1-5))
|
|
(enemy-method-57 obj a1-5 gp-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! v1-32 s3-2)
|
|
*collide-hit-by-others-list*
|
|
(set! s3-2 (-> s3-2 next0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((s4-1 (-> gp-0 proc)))
|
|
(when s4-1
|
|
(enemy-method-63
|
|
obj
|
|
(the-as process-focusable s4-1)
|
|
(the-as symbol (enemy-method-61 obj (the-as int (-> gp-0 aware))))
|
|
)
|
|
s4-1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 57 of type enemy
|
|
;; WARN: Return type mismatch int vs enemy-aware.
|
|
(defmethod enemy-method-57 enemy ((obj enemy) (arg0 process-focusable) (arg1 enemy-best-focus))
|
|
(let ((f30-0 (vector-vector-distance (get-trans arg0 0) (-> obj root-override2 trans)))
|
|
(s3-1 #f)
|
|
(s2-0 #f)
|
|
)
|
|
(cond
|
|
((< f30-0 (-> obj enemy-info proximity-notice-distance))
|
|
(set! s3-1 #t)
|
|
(set! s2-0 (enemy-method-98 obj arg0 (the-as vector #f)))
|
|
)
|
|
(else
|
|
(let ((f0-1 (the-as float (-> obj enemy-info notice-distance))))
|
|
(if (< 1 (the-as int (-> obj focus aware)))
|
|
(set! f0-1 (+ (the-as meters f0-1) (-> obj enemy-info notice-distance-delta)))
|
|
)
|
|
(when (or (< f30-0 f0-1) (zero? (logand (-> obj enemy-flags) (enemy-flag enable-on-notice))))
|
|
(set! s2-0 (enemy-method-98 obj arg0 (the-as vector #f)))
|
|
(if s2-0
|
|
(set! s3-1 #t)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((s3-2 (cond
|
|
(s3-1
|
|
(cond
|
|
((enemy-method-99 obj arg0)
|
|
4
|
|
)
|
|
(s2-0
|
|
3
|
|
)
|
|
(else
|
|
2
|
|
)
|
|
)
|
|
)
|
|
((< f30-0 (-> obj fact-info-override idle-distance))
|
|
1
|
|
)
|
|
(else
|
|
0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (and (> s3-2 0) (logtest? (enemy-flag called-dying) (-> obj enemy-flags)))
|
|
(cond
|
|
((logtest? (enemy-option idle-til-trigger) (-> obj fact-info-override enemy-options))
|
|
(if (not (enemy-method-130 obj f30-0))
|
|
(set! s3-2 0)
|
|
)
|
|
)
|
|
(else
|
|
(if (and (< 1 s3-2) (not (enemy-method-130 obj f30-0)))
|
|
(set! s3-2 1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when arg1
|
|
(when (and (>= s3-2 (the-as int (-> arg1 aware))) (< f30-0 (-> arg1 rating)))
|
|
(set! (-> arg1 aware) (the-as enemy-aware s3-2))
|
|
(set! (-> arg1 rating) f30-0)
|
|
(set! (-> arg1 proc) arg0)
|
|
)
|
|
)
|
|
(the-as enemy-aware s3-2)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 130 of type enemy
|
|
(defmethod enemy-method-130 enemy ((obj enemy) (arg0 float))
|
|
(let* ((v1-0 (-> obj fact-info-override))
|
|
(a2-0 (-> v1-0 trig-mask-count))
|
|
(a3-0 (-> v1-0 trig-mask))
|
|
)
|
|
(dotimes (t0-0 a2-0)
|
|
(let ((t1-1 (the-as int (-> a3-0 t0-0))))
|
|
(if (and (logtest? (the-as uint t1-1) 1) (>= (-> v1-0 trig-dist) arg0))
|
|
(set! t1-1 (the-as int (logand -2 (the-as uint t1-1))))
|
|
)
|
|
(when (logtest? (the-as uint t1-1) 2)
|
|
(let ((t2-8 (-> v1-0 trig-actor-group 0)))
|
|
(countdown (t3-0 (-> t2-8 length))
|
|
(let ((t5-0 (-> t2-8 data t3-0 actor)))
|
|
(when (and t5-0 (logtest? (-> t5-0 extra perm status) (entity-perm-status subtask-complete)))
|
|
(set! t1-1 (logand -3 t1-1))
|
|
(goto cfg-17)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(label cfg-17)
|
|
(when (zero? t1-1)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag called-dying))
|
|
(return #t)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
|
|
;; definition for method 61 of type enemy
|
|
(defmethod enemy-method-61 enemy ((obj enemy) (arg0 int))
|
|
(let ((v1-1 (< 1 arg0)))
|
|
(cond
|
|
(v1-1
|
|
(when (not (logtest? (-> obj enemy-flags) (enemy-flag spawn-gem)))
|
|
(logior! (-> obj enemy-flags) (enemy-flag spawn-gem))
|
|
(set! (-> obj notice-time) (the-as uint (-> self clock frame-counter)))
|
|
)
|
|
(if (and (not (logtest? (-> obj enemy-flags) (enemy-flag chase-startup)))
|
|
(< (- (-> self clock frame-counter) (the-as int (-> obj notice-time)))
|
|
(the-as time-frame (-> obj reaction-time))
|
|
)
|
|
)
|
|
(set! v1-1 #f)
|
|
)
|
|
)
|
|
(else
|
|
(logclear! (-> obj enemy-flags) (enemy-flag spawn-gem))
|
|
)
|
|
)
|
|
(cond
|
|
(v1-1
|
|
arg0
|
|
)
|
|
((or (zero? arg0) (>= (- (-> self clock frame-counter) (the-as int (-> obj last-draw-time))) (seconds 2)))
|
|
0
|
|
)
|
|
(else
|
|
1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 74 of type enemy
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch none vs object.
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 17]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 28]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 89]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 202]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 274]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 346]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 413]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 490]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 493]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 530]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 560]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 610]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 641]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 774]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 807]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 814]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 850]
|
|
;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 933]
|
|
(defmethod enemy-method-74 enemy ((obj enemy) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block))
|
|
(local-vars (s5-5 rgbaf) (sv-432 process) (sv-448 event-message-block))
|
|
(with-pp
|
|
(the-as
|
|
object
|
|
(cond
|
|
((= arg2 'track)
|
|
(and (nonzero? (-> obj hit-points))
|
|
(logtest? (-> obj enemy-flags) (enemy-flag enable-on-active))
|
|
(logtest? (enemy-flag check-water-backup) (-> obj enemy-flags))
|
|
)
|
|
)
|
|
((= arg2 'combo)
|
|
(and (not (logtest? (enemy-flag multi-focus) (-> obj enemy-flags))) (nonzero? (-> obj hit-points)))
|
|
)
|
|
((= arg2 'touch)
|
|
(enemy-method-75 obj arg0 (the-as touching-shapes-entry arg3))
|
|
)
|
|
((= arg2 'touched)
|
|
(when (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup))
|
|
(let* ((s3-1 arg0)
|
|
(v1-20 (if (type? s3-1 process-drawable)
|
|
(the-as process-drawable s3-1)
|
|
)
|
|
)
|
|
)
|
|
(when v1-20
|
|
(let* ((s3-2 (-> v1-20 root))
|
|
(a1-4 (if (type? s3-2 collide-shape)
|
|
s3-2
|
|
)
|
|
)
|
|
(s3-3 (-> arg3 param 0))
|
|
)
|
|
(if (and a1-4
|
|
s3-3
|
|
((method-of-type touching-shapes-entry prims-touching-action?)
|
|
(the-as touching-shapes-entry s3-3)
|
|
(the-as collide-shape a1-4)
|
|
(collide-action solid)
|
|
(collide-action)
|
|
)
|
|
((method-of-type touching-shapes-entry prims-touching-action?)
|
|
(the-as touching-shapes-entry s3-3)
|
|
(-> obj root-override2)
|
|
(collide-action solid)
|
|
(collide-action)
|
|
)
|
|
)
|
|
(set! (-> obj auto-reset-penetrate-time) (the-as uint (-> pp clock frame-counter)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(enemy-method-76 obj arg0 arg3)
|
|
)
|
|
((= arg2 'attack-invinc)
|
|
(case (-> (the-as attack-info (-> arg3 param 1)) mode)
|
|
(('endlessfall)
|
|
(let ((v1-31 (-> obj root-override2 root-prim)))
|
|
(set! (-> v1-31 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-31 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(enemy-method-73 obj)
|
|
)
|
|
)
|
|
)
|
|
((= arg2 'attack)
|
|
(let ((s2-0 (the-as object (-> arg3 param 1))))
|
|
(when (!= (-> (the-as attack-info s2-0) id) (-> obj incoming attack-id))
|
|
(cond
|
|
((and (logtest? (-> obj enemy-flags) (enemy-flag enable-on-active))
|
|
(zero? (logand (-> obj focus-status) (focus-status grabbed)))
|
|
)
|
|
(let* ((s1-0 obj)
|
|
(s0-0 (method-of-object s1-0 enemy-method-106))
|
|
)
|
|
(set! sv-432 arg0)
|
|
(set! sv-448 arg3)
|
|
(let ((a3-3 (get-penetrate-using-from-attack-event (the-as process-drawable arg0) arg3)))
|
|
(s0-0 s1-0 sv-432 sv-448 (the-as int a3-3) (the-as attack-info s2-0))
|
|
)
|
|
)
|
|
(send-event (ppointer->process (-> obj parent)) 'child-hit)
|
|
0
|
|
(if (not *debug-unkillable*)
|
|
(enemy-method-48 obj arg0 arg3)
|
|
)
|
|
(let ((s2-1 (the-as attack-info (enemy-method-58 obj arg0 arg3))))
|
|
(when s2-1
|
|
(logclear! (-> obj enemy-flags) (enemy-flag called-dying))
|
|
(enemy-method-108 obj (the-as enemy arg0) arg3)
|
|
(let ((a1-13 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> a1-13 from) (process->ppointer arg0))
|
|
(set! (-> a1-13 num-params) (the-as int arg1))
|
|
(set! (-> a1-13 message) (the-as symbol s2-1))
|
|
(set! (-> a1-13 param 0) (-> arg3 param 0))
|
|
(set! (-> a1-13 param 1) (-> arg3 param 1))
|
|
(set! (-> a1-13 param 2) (-> arg3 param 2))
|
|
(set! (-> a1-13 param 3) (-> arg3 param 3))
|
|
(set! (-> a1-13 param 4) (-> arg3 param 4))
|
|
(set! (-> a1-13 param 5) (-> arg3 param 5))
|
|
(send-event-function obj a1-13)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> obj incoming attack-id) (-> (the-as attack-info s2-0) id))
|
|
(enemy-method-75 obj arg0 (the-as touching-shapes-entry arg3))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
((= arg2 'hit-flinch)
|
|
(when (zero? (-> obj hit-points))
|
|
(logclear! (-> obj mask) (process-mask actor-pause))
|
|
(logclear! (-> obj focus-status) (focus-status dangerous))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
|
|
(logior! (-> obj enemy-flags) (enemy-flag chase-startup))
|
|
(logior! (-> obj focus-status) (focus-status hit))
|
|
(if (zero? (-> obj hit-points))
|
|
(logior! (-> obj focus-status) (focus-status dead))
|
|
)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
|
|
(enemy-method-62 obj)
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
|
|
(process-contact-action arg0)
|
|
(send-event arg0 'get-attack-count 1)
|
|
(enemy-method-73 obj)
|
|
)
|
|
#t
|
|
)
|
|
((= arg2 'hit-knocked)
|
|
(logclear! (-> obj mask) (process-mask actor-pause))
|
|
(logclear! (-> obj focus-status) (focus-status dangerous))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
|
|
(logior! (-> obj enemy-flags) (enemy-flag chase-startup))
|
|
(logior! (-> obj focus-status) (focus-status hit))
|
|
(if (zero? (-> obj hit-points))
|
|
(logior! (-> obj focus-status) (focus-status dead))
|
|
)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
|
|
(enemy-method-62 obj)
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
|
|
(process-contact-action arg0)
|
|
(send-event arg0 'get-attack-count 1)
|
|
(when (zero? (-> obj hit-points))
|
|
(case (-> obj incoming knocked-type)
|
|
(((knocked-type knocked-type-4) (knocked-type knocked-type-6))
|
|
(set! (-> obj incoming knocked-type) (knocked-type knocked-type-0))
|
|
0
|
|
)
|
|
)
|
|
)
|
|
(go (method-of-object obj knocked))
|
|
)
|
|
((= arg2 'hit)
|
|
(logclear! (-> obj mask) (process-mask actor-pause))
|
|
(logclear! (-> obj focus-status) (focus-status dangerous))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
|
|
(logior! (-> obj enemy-flags) (enemy-flag chase-startup))
|
|
(logior! (-> obj focus-status) (focus-status hit))
|
|
(if (zero? (-> obj hit-points))
|
|
(logior! (-> obj focus-status) (focus-status dead))
|
|
)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
|
|
(enemy-method-62 obj)
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
|
|
(process-contact-action arg0)
|
|
(send-event arg0 'get-attack-count 1)
|
|
(if (zero? (-> obj hit-points))
|
|
(enemy-method-73 obj)
|
|
(go (method-of-object obj hit))
|
|
)
|
|
)
|
|
((= arg2 'cue-chase)
|
|
(when (and (> (-> obj hit-points) 0)
|
|
(zero? (-> obj fated-time))
|
|
(zero? (logand (-> obj focus-status) (focus-status grabbed)))
|
|
)
|
|
(let ((v1-162 (logtest? (enemy-flag alert) (-> obj enemy-flags))))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice alert victory called-dying))
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag dangerous-backup) (-> obj enemy-flags)))
|
|
(logclear! (-> obj mask) (process-mask actor-pause))
|
|
(cond
|
|
(v1-162
|
|
(if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options))
|
|
(go-ambush obj)
|
|
(go-hostile obj)
|
|
)
|
|
)
|
|
((and (-> obj next-state) (let ((v1-173 (-> obj next-state name)))
|
|
(or (= v1-173 'dormant) (= v1-173 'dormant-aware))
|
|
)
|
|
)
|
|
(if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options))
|
|
(go-ambush obj)
|
|
(go (method-of-object obj notice))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
)
|
|
((= arg2 'cue-wake)
|
|
(when (and (> (-> obj hit-points) 0)
|
|
(zero? (-> obj fated-time))
|
|
(zero? (logand (-> obj focus-status) (focus-status grabbed)))
|
|
)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag alert victory called-dying))
|
|
(if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options))
|
|
(go-ambush obj)
|
|
(enemy-method-72 obj)
|
|
)
|
|
#t
|
|
)
|
|
)
|
|
((= arg2 'jump)
|
|
(when (and (> (-> obj hit-points) 0)
|
|
(zero? (-> obj fated-time))
|
|
(zero? (logand (-> obj focus-status) (focus-status grabbed)))
|
|
)
|
|
(logclear! (-> obj mask) (process-mask actor-pause))
|
|
(set! (-> obj jump-why) (-> arg3 param 0))
|
|
(set! (-> obj event-param-point quad) (-> (the-as vector (-> arg3 param 1)) quad))
|
|
(go (method-of-object obj jump))
|
|
)
|
|
)
|
|
((= arg2 'death-start)
|
|
(set! (-> obj enemy-flags) (the-as enemy-flag (logior (enemy-flag recover) (-> obj enemy-flags))))
|
|
(send-event (ppointer->process (-> obj parent)) 'child-die)
|
|
(drop-pickup (-> obj fact-info-override) #t *entity-pool* (-> obj fact-info-override) 0)
|
|
(let ((s5-1 (-> obj on-death)))
|
|
(if s5-1
|
|
(eval!
|
|
(new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (-> obj root-override2 trans))
|
|
(the-as pair s5-1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
((= arg2 'death-end)
|
|
(if (-> obj skel effect)
|
|
(logior! (-> obj skel effect flags) (effect-control-flag ecf2))
|
|
)
|
|
(logior! (-> obj draw status) (draw-control-status no-draw))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water))
|
|
(logclear! (-> obj focus-status) (focus-status dangerous))
|
|
(set! (-> obj enemy-flags) (logclear (-> obj enemy-flags) (enemy-flag check-water)))
|
|
)
|
|
((= arg2 'instant-death)
|
|
(when (and (> (-> obj hit-points) 0) (zero? (-> obj fated-time)))
|
|
(set! (-> obj hit-points) 0)
|
|
(set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj))
|
|
(let ((s5-2 (enemy-method-50 obj (new 'stack-no-clear 'vector))))
|
|
(vector-z-quaternion! s5-2 (-> obj root-override2 quat))
|
|
(vector-float*! s5-2 s5-2 -1.0)
|
|
(vector-normalize! s5-2 1.0)
|
|
)
|
|
(logclear! (-> obj mask) (process-mask actor-pause))
|
|
(logclear! (-> obj focus-status) (focus-status dangerous))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice))
|
|
(logior! (-> obj enemy-flags) (enemy-flag chase-startup))
|
|
(logior! (-> obj focus-status) (focus-status hit))
|
|
(if (zero? (-> obj hit-points))
|
|
(logior! (-> obj focus-status) (focus-status dead))
|
|
)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup))
|
|
(enemy-method-62 obj)
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags)))
|
|
(enemy-method-73 obj)
|
|
)
|
|
)
|
|
((= arg2 'die-fast)
|
|
(logior! (-> obj draw status) (draw-control-status no-draw))
|
|
(enemy-method-132 obj)
|
|
(send-event (ppointer->process (-> obj parent)) 'child-die)
|
|
(let ((s5-3 (-> obj on-death)))
|
|
(if s5-3
|
|
(eval!
|
|
(new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (-> obj root-override2 trans))
|
|
(the-as pair s5-3)
|
|
)
|
|
)
|
|
)
|
|
(cleanup-for-death obj)
|
|
(go (method-of-object obj die-fast))
|
|
)
|
|
((= arg2 'victory)
|
|
(if (and (-> obj enemy-info use-victory)
|
|
(not (and (-> obj next-state) (= (-> obj next-state name) 'victory)))
|
|
(> (-> obj hit-points) 0)
|
|
(zero? (-> obj fated-time))
|
|
(zero? (logand (-> obj focus-status) (focus-status grabbed)))
|
|
)
|
|
(go (method-of-object obj victory))
|
|
)
|
|
)
|
|
((= arg2 'nav-control)
|
|
(if (nonzero? (-> obj nav))
|
|
(-> obj nav)
|
|
)
|
|
)
|
|
((= arg2 'push-trans)
|
|
(move-by-vector! (-> obj root-override2) (the-as vector (-> arg3 param 0)))
|
|
)
|
|
((= arg2 'move-trans)
|
|
(move-to-point! (-> obj root-override2) (the-as vector (-> arg3 param 0)))
|
|
)
|
|
((= arg2 'shadow)
|
|
(cond
|
|
((-> arg3 param 0)
|
|
(let ((v1-320 (-> obj draw shadow-ctrl)))
|
|
(logclear! (-> v1-320 settings flags) (shadow-flags disable-draw))
|
|
)
|
|
0
|
|
)
|
|
(else
|
|
(let ((v1-323 (-> obj draw shadow-ctrl)))
|
|
(logior! (-> v1-323 settings flags) (shadow-flags disable-draw))
|
|
)
|
|
0
|
|
)
|
|
)
|
|
)
|
|
((= arg2 'color-effect)
|
|
(case (-> arg3 param 0)
|
|
(('dark)
|
|
(let ((f30-0 (rand-vu-float-range 0.2 1.0)))
|
|
(set-vector! (-> obj draw color-mult) (lerp 1.0 1.0 f30-0) (lerp 1.0 0.0 f30-0) (lerp 1.0 1.0 f30-0) 1.0)
|
|
(set! s5-5 (-> obj draw color-emissive))
|
|
(set! (-> s5-5 x) (lerp 0.0 0.3 f30-0))
|
|
(set! (-> s5-5 y) (lerp 0.0 0.0 f30-0))
|
|
(set! (-> s5-5 z) (lerp 0.0 0.3 f30-0))
|
|
)
|
|
(set! (-> s5-5 w) 1.0)
|
|
s5-5
|
|
)
|
|
((#f)
|
|
(set-vector! (-> obj draw color-mult) 1.0 1.0 1.0 1.0)
|
|
(set! s5-5 (-> obj draw color-emissive))
|
|
(set! (-> s5-5 quad) (the-as uint128 0))
|
|
s5-5
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 56 of type enemy
|
|
(defmethod enemy-method-56 enemy ((obj enemy) (arg0 process) (arg1 event-message-block))
|
|
(let ((v1-0 (the-as attack-info (-> arg1 param 1))))
|
|
(if (logtest? (attack-info-mask damage) (-> v1-0 mask))
|
|
(the int (-> v1-0 damage))
|
|
(penetrate-using->damage (the-as penetrate (-> obj incoming penetrate-using)))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 58 of type enemy
|
|
(defmethod enemy-method-58 enemy ((obj enemy) (arg0 process) (arg1 event-message-block))
|
|
(let ((v1-0 (-> obj incoming penetrate-using)))
|
|
(cond
|
|
((logtest? (the-as penetrate v1-0) (-> obj penetrated-flinch))
|
|
'hit-flinch
|
|
)
|
|
((logtest? (the-as penetrate v1-0) (-> obj penetrated-knocked))
|
|
'hit-knocked
|
|
)
|
|
(else
|
|
'hit
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 48 of type enemy
|
|
(defmethod enemy-method-48 enemy ((obj enemy) (arg0 process) (arg1 event-message-block))
|
|
(with-pp
|
|
(let* ((v1-1 (enemy-method-56 obj arg0 arg1))
|
|
(s5-0 (-> obj hit-points))
|
|
(s4-1 (max 0 (- s5-0 v1-1)))
|
|
)
|
|
(when (and (zero? s4-1) (nonzero? s5-0) (= (-> obj incoming knocked-type) (knocked-type knocked-type-6)))
|
|
(cond
|
|
((zero? (-> obj fated-time))
|
|
(set! (-> obj fated-time) (the-as uint (-> pp clock frame-counter)))
|
|
(set! s4-1 1)
|
|
)
|
|
(else
|
|
(if (< (- (-> pp clock frame-counter) (the-as int (-> obj fated-time))) (seconds 1))
|
|
(set! s4-1 1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj hit-points) s4-1)
|
|
(if (not (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup)))
|
|
(set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj))
|
|
)
|
|
(- s5-0 s4-1)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 134 of type enemy
|
|
(defmethod enemy-method-134 enemy ((obj enemy) (arg0 process) (arg1 attack-info))
|
|
(find-offending-process-focusable arg0 arg1)
|
|
)
|
|
|
|
;; definition for method 75 of type enemy
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod enemy-method-75 enemy ((obj enemy) (arg0 process) (arg1 touching-shapes-entry))
|
|
(let* ((s4-0 (-> arg1 handle1))
|
|
(s2-0 arg0)
|
|
(s3-0 (if (type? s2-0 process-focusable)
|
|
(the-as process-focusable s2-0)
|
|
)
|
|
)
|
|
)
|
|
(when (and s4-0 s3-0)
|
|
(cond
|
|
((and (logtest? (-> obj focus-status) (focus-status dangerous))
|
|
(and s3-0 (zero? (logand (-> s3-0 focus-status) (focus-status disable dead ignore grabbed))))
|
|
((method-of-type touching-shapes-entry prims-touching-action?)
|
|
(the-as touching-shapes-entry s4-0)
|
|
(-> obj root-override2)
|
|
(collide-action deadly)
|
|
(collide-action)
|
|
)
|
|
)
|
|
(let ((a3-2 (if ((method-of-type touching-shapes-entry prims-touching-action?)
|
|
(the-as touching-shapes-entry s4-0)
|
|
(-> obj root-override2)
|
|
(collide-action persistent-attack)
|
|
(collide-action)
|
|
)
|
|
(-> obj persistent-attack-id)
|
|
(-> obj attack-id)
|
|
)
|
|
)
|
|
)
|
|
(enemy-method-104 obj arg0 (the-as uint s4-0) a3-2)
|
|
)
|
|
)
|
|
((and ((method-of-type touching-shapes-entry prims-touching-action?)
|
|
(the-as touching-shapes-entry s4-0)
|
|
(-> obj root-override2)
|
|
(collide-action no-standon)
|
|
(collide-action)
|
|
)
|
|
(zero? (logand (-> obj root-override2 penetrated-by) (-> s3-0 root-override penetrate-using)))
|
|
)
|
|
(if (send-shoves (-> obj root-override2) arg0 (the-as touching-shapes-entry s4-0) 0.7 6144.0 16384.0)
|
|
(send-event obj 'bouncing-off arg0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 76 of type enemy
|
|
(defmethod enemy-method-76 enemy ((obj enemy) (arg0 process) (arg1 event-message-block))
|
|
(let ((s4-0 (-> arg1 param 0)))
|
|
(when s4-0
|
|
(when (or (and (and (-> obj next-state) (= (-> obj next-state name) 'knocked))
|
|
(logtest? (process-mask crate) (-> arg0 mask))
|
|
)
|
|
(and (and (-> obj next-state) (= (-> obj next-state name) 'jump))
|
|
(logtest? (process-mask target sidekick crate bot) (-> arg0 mask))
|
|
)
|
|
)
|
|
(when ((method-of-type touching-shapes-entry prims-touching-action?)
|
|
(the-as touching-shapes-entry s4-0)
|
|
(-> obj root-override2)
|
|
(collide-action solid semi-solid deadly)
|
|
(collide-action)
|
|
)
|
|
(let ((a3-2 (if ((method-of-type touching-shapes-entry prims-touching-action?)
|
|
(the-as touching-shapes-entry s4-0)
|
|
(-> obj root-override2)
|
|
(collide-action persistent-attack)
|
|
(collide-action)
|
|
)
|
|
(-> obj persistent-attack-id)
|
|
(-> obj attack-id)
|
|
)
|
|
)
|
|
)
|
|
(enemy-method-104 obj arg0 s4-0 a3-2)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function enemy-event-handler
|
|
(defbehavior enemy-event-handler enemy ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
|
|
(enemy-method-74 self arg0 arg1 arg2 arg3)
|
|
)
|
|
|
|
;; definition for function enemy-simple-post
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defbehavior enemy-simple-post enemy ()
|
|
(enemy-method-55 self)
|
|
(update-transforms (-> self root-override2))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function enemy-falling-post
|
|
;; INFO: Used lq/sq
|
|
(defbehavior enemy-falling-post enemy ()
|
|
(set! (-> self enemy-flags) (logior (enemy-flag directed) (-> self enemy-flags)))
|
|
(let ((gp-0 (-> self root-override2)))
|
|
(cond
|
|
((logtest? (-> self focus-status) (focus-status under-water))
|
|
(enemy-method-47 self (-> gp-0 transv))
|
|
)
|
|
(else
|
|
(let ((a1-1 (new-stack-vector0)))
|
|
(vector-v++! (-> gp-0 transv) (compute-acc-due-to-gravity gp-0 a1-1 (-> self enemy-info slip-factor)))
|
|
)
|
|
)
|
|
)
|
|
(let ((a2-1 (new 'stack-no-clear 'collide-query)))
|
|
(set! (-> a2-1 collide-with) (-> gp-0 root-prim prim-core collide-with))
|
|
(set! (-> a2-1 ignore-process0) self)
|
|
(set! (-> a2-1 ignore-process1) #f)
|
|
(set! (-> a2-1 ignore-pat) (logior (new 'static 'pat-surface :noendlessfall #x1) (-> gp-0 pat-ignore-mask)))
|
|
(set! (-> a2-1 action-mask) (collide-action solid))
|
|
(fill-cache-integrate-and-collide gp-0 (-> gp-0 transv) a2-1 (meters 0))
|
|
)
|
|
)
|
|
(enemy-method-111 self)
|
|
(enemy-method-55 self)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 47 of type enemy
|
|
(defmethod enemy-method-47 enemy ((obj enemy) (arg0 vector))
|
|
(with-pp
|
|
(let* ((f2-0 0.8)
|
|
(f0-1 (fmax 0.0 (+ 1.0 (* 60.0 (-> pp clock seconds-per-frame) (+ -1.0 f2-0)))))
|
|
)
|
|
(vector-float*! arg0 arg0 f0-1)
|
|
)
|
|
(set! (-> arg0 y) (+ (-> arg0 y) (* -204800.0 (-> pp clock seconds-per-frame))))
|
|
)
|
|
)
|
|
|
|
;; definition for function enemy-die-falling-post
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defbehavior enemy-die-falling-post enemy ()
|
|
(set! (-> self enemy-flags) (logior (enemy-flag directed) (-> self enemy-flags)))
|
|
(let ((gp-0 (-> self root-override2)))
|
|
(if (logtest? (-> self focus-status) (focus-status under-water))
|
|
(enemy-method-47 self (-> gp-0 transv))
|
|
(vector-v++! (-> gp-0 transv) (compute-acc-due-to-gravity gp-0 (new-stack-vector0) 0.0))
|
|
)
|
|
(let ((s4-1 (new 'stack-no-clear 'collide-query))
|
|
(s5-1 (new 'stack-no-clear 'vector))
|
|
)
|
|
(set! (-> s5-1 quad) (-> gp-0 trans quad))
|
|
(vector-v++! s5-1 (-> gp-0 transv))
|
|
(when (find-ground gp-0 s4-1 (-> self enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0)
|
|
(when (>= (-> gp-0 gspot-pos y) (-> s5-1 y))
|
|
(set! (-> s5-1 y) (-> gp-0 gspot-pos y))
|
|
(vector-reset! (-> gp-0 transv))
|
|
)
|
|
)
|
|
(move-to-point! gp-0 s5-1)
|
|
)
|
|
)
|
|
(enemy-method-55 self)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate idle (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(enemy-method-110 self)
|
|
(logclear! (-> self enemy-flags) (enemy-flag spawn-gem chase-startup use-notice-distance))
|
|
(logior! (-> self enemy-flags) (enemy-flag enable-on-notice))
|
|
(set! (-> self state-timeout) (the-as uint 150))
|
|
(if (-> self on-notice)
|
|
(logior! (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
|
|
)
|
|
(if (-> self on-active)
|
|
(logior! (-> self enemy-flags) (enemy-flag jump-check-blocked))
|
|
)
|
|
(if (-> self on-hostile)
|
|
(logior! (-> self enemy-flags) (enemy-flag drawn-mirrored))
|
|
)
|
|
(when (not (logtest? (enemy-flag dangerous-backup) (-> self enemy-flags)))
|
|
(if (logtest? (-> self enemy-flags) (enemy-flag notice))
|
|
(logior! (-> self mask) (process-mask actor-pause))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:trans (behavior ()
|
|
(if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self state-timeout)))
|
|
(> (the-as int (-> self focus aware)) 0)
|
|
)
|
|
(go-virtual active)
|
|
)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.1))
|
|
(sleep-code)
|
|
(none)
|
|
)
|
|
:post (behavior ()
|
|
(idle-control-method-10 (-> self idle-anim-player) self)
|
|
(if (and (nonzero? (-> self draw)) (logtest? (-> self draw status) (draw-control-status on-screen)))
|
|
(set! (-> self last-draw-time) (the-as uint (-> self clock frame-counter)))
|
|
)
|
|
(enemy-method-129 self)
|
|
(ja-post)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate dormant (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
((-> (method-of-type enemy idle) enter))
|
|
(set! (-> self root-override2 nav-flags) (nav-flags))
|
|
(let ((v1-4 (-> self root-override2 root-prim)))
|
|
(set! (-> v1-4 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-4 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(logior! (-> self draw status) (draw-control-status no-draw))
|
|
(set! (-> self draw origin quad) (-> self root-override2 trans quad))
|
|
(if (logtest? (enemy-flag alert) (-> self enemy-flags))
|
|
(set! (-> self enemy-flags) (logior (enemy-flag victory) (-> self enemy-flags)))
|
|
)
|
|
(logior! (-> self focus-status) (focus-status disable))
|
|
(none)
|
|
)
|
|
:exit (behavior ()
|
|
(logclear! (-> self focus-status) (focus-status disable))
|
|
(let ((v1-3 (-> self root-override2 root-prim)))
|
|
(set! (-> v1-3 prim-core collide-as) (-> self root-override2 backup-collide-as))
|
|
(set! (-> v1-3 prim-core collide-with) (-> self root-override2 backup-collide-with))
|
|
)
|
|
(logclear! (-> self draw status) (draw-control-status no-draw))
|
|
(logclear! (-> self enemy-flags) (enemy-flag victory))
|
|
(logior! (-> self root-override2 nav-flags) (nav-flags has-root-sphere))
|
|
(none)
|
|
)
|
|
:code (the-as (function none :behavior enemy) sleep-code)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate dormant-aware (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (-> (method-of-type enemy dormant) enter)
|
|
:exit (-> (method-of-type enemy dormant) exit)
|
|
:trans (behavior ()
|
|
(when (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self state-timeout)))
|
|
(> (the-as int (-> self focus aware)) 0)
|
|
)
|
|
(if (logtest? (enemy-option ambush) (-> self fact-info-override enemy-options))
|
|
(go-ambush self)
|
|
(go-virtual active)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:code (the-as (function none :behavior enemy) sleep-code)
|
|
:post (behavior ()
|
|
(if (and (nonzero? (-> self draw)) (logtest? (-> self draw status) (draw-control-status on-screen)))
|
|
(set! (-> self last-draw-time) (the-as uint (-> self clock frame-counter)))
|
|
)
|
|
(enemy-method-129 self)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate ambush (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(logior! (-> self enemy-flags) (enemy-flag chase-startup))
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(go-virtual notice)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(logclear! (-> self enemy-flags) (enemy-flag use-notice-distance))
|
|
(when (logtest? (-> self enemy-flags) (enemy-flag jump-check-blocked))
|
|
(logclear! (-> self enemy-flags) (enemy-flag jump-check-blocked))
|
|
(let ((gp-0 (-> self on-active)))
|
|
(if gp-0
|
|
(eval!
|
|
(new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
|
|
(the-as pair gp-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (not (logtest? (enemy-flag dangerous-backup) (-> self enemy-flags)))
|
|
(if (logtest? (-> self enemy-flags) (enemy-flag notice))
|
|
(logior! (-> self mask) (process-mask actor-pause))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:trans (behavior ()
|
|
(when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
|
|
(let ((v1-3 (-> self focus aware)))
|
|
(cond
|
|
((< (the-as int v1-3) 1)
|
|
(go-virtual idle)
|
|
)
|
|
((< 1 (the-as int v1-3))
|
|
(go-virtual notice)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.1))
|
|
(sleep-code)
|
|
(none)
|
|
)
|
|
:post (behavior ()
|
|
(idle-control-method-10 (-> self idle-anim-player) self)
|
|
(enemy-simple-post)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate notice (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(let ((v1-3 (logior (-> self enemy-flags) (enemy-flag use-notice-distance))))
|
|
(set! (-> self enemy-flags) (logclear v1-3 (enemy-flag called-dying)))
|
|
)
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(enemy-method-109 self 1)
|
|
(when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
|
|
(logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate))
|
|
(let ((gp-0 (-> self on-notice)))
|
|
(if gp-0
|
|
(eval!
|
|
(new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
|
|
(the-as pair gp-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((gp-1 (-> self focus aware)))
|
|
(when (logtest? (-> self enemy-flags) (enemy-flag chase-startup))
|
|
(cond
|
|
((and (= gp-1 (enemy-aware enemy-aware-3)) (enemy-method-107 self))
|
|
(go-hostile self)
|
|
)
|
|
((= gp-1 (enemy-aware enemy-aware-4))
|
|
(go-flee self)
|
|
)
|
|
(else
|
|
(go-stare self)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(logior! (-> self enemy-flags) (enemy-flag chase-startup))
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.075))
|
|
(let ((f30-0 (get-rand-float-range self 0.8 1.2))
|
|
(gp-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
(ja-no-eval :group! (-> self draw art-group data (-> self enemy-info notice-anim))
|
|
:num! (seek!
|
|
(the float
|
|
(+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info notice-anim))) frames num-frames)
|
|
-1
|
|
)
|
|
)
|
|
f30-0
|
|
)
|
|
:frame-num 0.0
|
|
)
|
|
(until (ja-done? 0)
|
|
(vector-! gp-0 (target-pos 0) (-> self root-override2 trans))
|
|
(seek-toward-heading-vec! (-> self root-override2) gp-0 131072.0 (seconds 0.05))
|
|
(suspend)
|
|
(ja :num! (seek! max f30-0))
|
|
)
|
|
)
|
|
(enemy-method-72 self)
|
|
(none)
|
|
)
|
|
:post enemy-simple-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate hostile (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(enemy-method-109 self 1)
|
|
(logior! (-> self enemy-flags) (enemy-flag use-notice-distance))
|
|
(logclear! (-> self enemy-flags) (enemy-flag dangerous-backup))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(when (logtest? (-> self enemy-flags) (enemy-flag drawn-mirrored))
|
|
(logclear! (-> self enemy-flags) (enemy-flag drawn-mirrored))
|
|
(let ((gp-0 (-> self on-hostile)))
|
|
(if gp-0
|
|
(eval!
|
|
(new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans))
|
|
(the-as pair gp-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:trans (behavior ()
|
|
(if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory))
|
|
(go-virtual victory)
|
|
)
|
|
(let ((gp-0 (-> self focus aware)))
|
|
(when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
|
|
(cond
|
|
((or (>= 2 (the-as int gp-0)) (not (enemy-method-107 self)))
|
|
(go-stare self)
|
|
)
|
|
((= gp-0 (enemy-aware enemy-aware-4))
|
|
(go-flee self)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.2))
|
|
(ja :group! (-> self draw art-group data (-> self enemy-info hostile-anim)))
|
|
(ja :num-func num-func-identity :frame-num 0.0)
|
|
(let ((f30-0 (get-rand-float-range self 0.9 1.1)))
|
|
(until #f
|
|
(suspend)
|
|
(ja :num! (loop! f30-0))
|
|
)
|
|
)
|
|
#f
|
|
(none)
|
|
)
|
|
:post enemy-simple-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate stare (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(logclear! (-> self enemy-flags) (enemy-flag dangerous-backup))
|
|
(none)
|
|
)
|
|
:trans (behavior ()
|
|
(when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1))
|
|
(let ((gp-0 (-> self focus aware)))
|
|
(cond
|
|
((>= 1 (the-as int gp-0))
|
|
(go-virtual active)
|
|
)
|
|
((and (= gp-0 (enemy-aware enemy-aware-3)) (enemy-method-107 self))
|
|
(go-hostile self)
|
|
)
|
|
((= gp-0 (enemy-aware enemy-aware-4))
|
|
(go-flee self)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.1))
|
|
(let ((f30-0 (get-rand-float-range self 0.9 1.1))
|
|
(gp-0 (-> self draw art-group data (-> self enemy-info idle-anim)))
|
|
)
|
|
(until #f
|
|
(ja-no-eval :group! gp-0
|
|
:num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0)
|
|
:frame-num 0.0
|
|
)
|
|
(until (ja-done? 0)
|
|
(suspend)
|
|
(ja :num! (seek! max f30-0))
|
|
)
|
|
)
|
|
)
|
|
#f
|
|
(none)
|
|
)
|
|
:post enemy-simple-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate victory (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(logclear! (-> self enemy-flags) (enemy-flag look-at-focus))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.075))
|
|
(let ((f30-0 (get-rand-float-range self 0.8 1.2)))
|
|
(ja-no-eval :group! (-> self draw art-group data (-> self enemy-info victory-anim))
|
|
:num! (seek!
|
|
(the float
|
|
(+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info victory-anim))) frames num-frames)
|
|
-1
|
|
)
|
|
)
|
|
f30-0
|
|
)
|
|
:frame-num 0.0
|
|
)
|
|
(until (ja-done? 0)
|
|
(suspend)
|
|
(ja :num! (seek! max f30-0))
|
|
)
|
|
)
|
|
(enemy-method-72 self)
|
|
(none)
|
|
)
|
|
:post enemy-simple-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate flee (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(enemy-method-109 self 1)
|
|
(logclear! (-> self enemy-flags) (enemy-flag dangerous-backup))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(none)
|
|
)
|
|
:trans (behavior ()
|
|
(when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time)))
|
|
(if (!= (-> self focus aware) (enemy-aware enemy-aware-4))
|
|
(go-stare self)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.2))
|
|
(ja :group! (-> self draw art-group data (-> self enemy-info hostile-anim)))
|
|
(ja :num-func num-func-identity :frame-num 0.0)
|
|
(let ((f30-0 (get-rand-float-range self 0.9 1.1)))
|
|
(until #f
|
|
(suspend)
|
|
(ja :num! (loop! f30-0))
|
|
)
|
|
)
|
|
#f
|
|
(none)
|
|
)
|
|
:post enemy-simple-post
|
|
)
|
|
|
|
;; definition for method 82 of type enemy
|
|
(defmethod enemy-method-82 enemy ((obj enemy) (arg0 enemy-jump-info))
|
|
"@abstract"
|
|
#f
|
|
)
|
|
|
|
;; definition for method 83 of type enemy
|
|
;; INFO: Used lq/sq
|
|
(defmethod enemy-method-83 enemy ((obj enemy) (arg0 enemy-jump-info))
|
|
(set! (-> arg0 flags) (the-as uint 1))
|
|
(set! (-> arg0 anim-speed) (get-rand-float-range obj 0.9 1.1))
|
|
(set! (-> arg0 hang-time) 0)
|
|
(set! (-> arg0 dest-pos quad) (-> obj event-param-point quad))
|
|
(set! (-> arg0 start-pos quad) (-> obj root-override2 trans quad))
|
|
(let ((s4-0 (new 'stack-no-clear 'collide-query)))
|
|
(if (enemy-method-126
|
|
obj
|
|
s4-0
|
|
(-> arg0 dest-pos)
|
|
(the-as collide-spec (-> obj gnd-collide))
|
|
8192.0
|
|
81920.0
|
|
1024.0
|
|
)
|
|
(set! (-> arg0 dest-pos y) (-> s4-0 best-other-tri intersect y))
|
|
)
|
|
)
|
|
(enemy-method-84 obj arg0)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 84 of type enemy
|
|
(defmethod enemy-method-84 enemy ((obj enemy) (arg0 enemy-jump-info))
|
|
(let* ((f0-0 (vector-vector-xz-distance (-> arg0 start-pos) (-> arg0 dest-pos)))
|
|
(f0-2 (fmax (-> obj enemy-info jump-height-min) (* (-> obj enemy-info jump-height-factor) f0-0)))
|
|
)
|
|
(setup-from-to-height! (-> arg0 traj) (-> arg0 start-pos) (-> arg0 dest-pos) f0-2 -4.551111)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 86 of type enemy
|
|
(defmethod enemy-method-86 enemy ((obj enemy))
|
|
(let ((gp-0 (-> obj root-override2)))
|
|
(when (< (-> gp-0 transv y) 0.0)
|
|
(let ((a1-0 (new 'stack-no-clear 'collide-query)))
|
|
(find-ground (-> obj root-override2) a1-0 (the-as collide-spec (-> obj gnd-collide)) 8192.0 81920.0 1024.0)
|
|
)
|
|
(>= (-> gp-0 gspot-pos y) (-> gp-0 trans y))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 85 of type enemy
|
|
(defmethod enemy-method-85 enemy ((obj enemy))
|
|
(let* ((v1-0 (-> obj root-override2))
|
|
(f0-0 (-> v1-0 gspot-pos y))
|
|
)
|
|
(if (< (-> v1-0 trans y) f0-0)
|
|
(set! (-> v1-0 trans y) f0-0)
|
|
)
|
|
)
|
|
(set! (-> obj root-override2 transv y) 0.0)
|
|
)
|
|
|
|
;; definition for method 92 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-92 enemy ((obj enemy) (arg0 int) (arg1 nav-poly))
|
|
"TODO - nav-poly is a guess
|
|
@abstract"
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 91 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-91 enemy ((obj enemy) (arg0 int) (arg1 enemy-jump-info))
|
|
(case arg0
|
|
((2 3)
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag directed) (-> obj enemy-flags)))
|
|
(let ((f30-0 (the float (-> arg1 hang-time))))
|
|
(let ((a1-3 (compute-trans-at-time (-> arg1 traj) f30-0 (new 'stack-no-clear 'vector))))
|
|
(move-to-point! (-> obj root-override2) a1-3)
|
|
)
|
|
(let ((s5-1 (-> obj root-override2 transv)))
|
|
(compute-transv-at-time (-> arg1 traj) f30-0 s5-1)
|
|
(vector-float*! s5-1 s5-1 300.0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 89 of type enemy
|
|
(defmethod enemy-method-89 enemy ((obj enemy) (arg0 enemy-jump-info))
|
|
(let ((a0-1 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-1 param 0) 1.0)
|
|
(joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!)
|
|
)
|
|
(ja-channel-push! 1 (seconds 0.1))
|
|
(let ((a1-3 (-> obj draw art-group data (-> obj enemy-info jump-wind-up-anim)))
|
|
(a0-5 (-> obj skel root-channel 0))
|
|
)
|
|
(set! (-> a0-5 frame-group) (the-as art-joint-anim a1-3))
|
|
(set! (-> a0-5 param 0) (the float (+ (-> (the-as art-joint-anim a1-3) frames num-frames) -1)))
|
|
(set! (-> a0-5 param 1) (-> arg0 anim-speed))
|
|
(set! (-> a0-5 frame-num) 0.0)
|
|
(joint-control-channel-group! a0-5 (the-as art-joint-anim a1-3) num-func-seek!)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for method 87 of type enemy
|
|
(defmethod enemy-method-87 enemy ((obj enemy) (arg0 enemy-jump-info))
|
|
(let ((s5-0 (-> obj draw art-group data (-> obj enemy-info jump-in-air-anim))))
|
|
(let ((v1-6 (if (> (-> obj skel active-channels) 0)
|
|
(-> obj skel root-channel 0 frame-group)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((and v1-6 (= v1-6 (-> obj draw art-group data (-> obj enemy-info jump-wind-up-anim))))
|
|
(ja-channel-push! 1 0)
|
|
)
|
|
(else
|
|
(let ((a0-10 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-10 param 0) 1.0)
|
|
(joint-control-channel-group! a0-10 (the-as art-joint-anim #f) num-func-loop!)
|
|
)
|
|
(ja-channel-push! 1 (seconds 0.1))
|
|
)
|
|
)
|
|
)
|
|
(let ((a0-12 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-12 frame-group) (the-as art-joint-anim s5-0))
|
|
(set! (-> a0-12 param 0) (the float (+ (-> (the-as art-joint-anim s5-0) frames num-frames) -1)))
|
|
(set! (-> a0-12 param 1) (-> arg0 anim-speed))
|
|
(set! (-> a0-12 frame-num) 0.0)
|
|
(joint-control-channel-group! a0-12 (the-as art-joint-anim s5-0) num-func-seek!)
|
|
)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for method 88 of type enemy
|
|
(defmethod enemy-method-88 enemy ((obj enemy) (arg0 enemy-jump-info))
|
|
(let ((a0-1 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-1 param 0) 1.0)
|
|
(joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!)
|
|
)
|
|
(ja-channel-push! 1 (seconds 0.075))
|
|
(let ((a1-3 (-> obj draw art-group data (-> obj enemy-info jump-land-anim)))
|
|
(a0-5 (-> obj skel root-channel 0))
|
|
)
|
|
(set! (-> a0-5 frame-group) (the-as art-joint-anim a1-3))
|
|
(set! (-> a0-5 param 0) (the float (+ (-> (the-as art-joint-anim a1-3) frames num-frames) -1)))
|
|
(set! (-> a0-5 param 1) (-> arg0 anim-speed))
|
|
(set! (-> a0-5 frame-num) 0.0)
|
|
(joint-control-channel-group! a0-5 (the-as art-joint-anim a1-3) num-func-seek!)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for method 90 of type enemy
|
|
(defmethod enemy-method-90 enemy ((obj enemy) (arg0 int) (arg1 enemy-jump-info))
|
|
(local-vars (s5-0 symbol))
|
|
(let ((v1-0 arg0))
|
|
(cond
|
|
((zero? v1-0)
|
|
(not (enemy-method-89 obj arg1))
|
|
)
|
|
((= v1-0 1)
|
|
(set! s5-0 (ja-done? 0))
|
|
(let ((a0-4 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-4 param 0) (the float (+ (-> a0-4 frame-group frames num-frames) -1)))
|
|
(set! (-> a0-4 param 1) (-> arg1 anim-speed))
|
|
(joint-control-channel-group-eval! a0-4 (the-as art-joint-anim #f) num-func-seek!)
|
|
)
|
|
(ja-blend-eval)
|
|
s5-0
|
|
)
|
|
((= v1-0 2)
|
|
(enemy-method-87 obj arg1)
|
|
#f
|
|
)
|
|
((= v1-0 3)
|
|
(set! s5-0 (ja-done? 0))
|
|
(let ((a0-9 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-9 param 0) (the float (+ (-> a0-9 frame-group frames num-frames) -1)))
|
|
(set! (-> a0-9 param 1) (-> arg1 anim-speed))
|
|
(joint-control-channel-group-eval! a0-9 (the-as art-joint-anim #f) num-func-seek!)
|
|
)
|
|
(ja-blend-eval)
|
|
s5-0
|
|
)
|
|
((= v1-0 4)
|
|
(not (enemy-method-88 obj arg1))
|
|
)
|
|
((= v1-0 5)
|
|
(set! s5-0 (ja-done? 0))
|
|
(let ((a0-14 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-14 param 0) (the float (+ (-> a0-14 frame-group frames num-frames) -1)))
|
|
(set! (-> a0-14 param 1) (-> arg1 anim-speed))
|
|
(joint-control-channel-group-eval! a0-14 (the-as art-joint-anim #f) num-func-seek!)
|
|
)
|
|
(ja-blend-eval)
|
|
s5-0
|
|
)
|
|
(else
|
|
#t
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate jump (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(logior! (-> self focus-status) (focus-status dangerous))
|
|
(let* ((v1-6 *game-info*)
|
|
(a0-2 (+ (-> v1-6 attack-id) 1))
|
|
)
|
|
(set! (-> v1-6 attack-id) a0-2)
|
|
(set! (-> self attack-id) a0-2)
|
|
)
|
|
(logclear! (-> self focus-status) (focus-status in-air))
|
|
(none)
|
|
)
|
|
:exit (behavior ()
|
|
(if (logtest? (-> self enemy-flags) (enemy-flag check-water))
|
|
(logior! (-> self focus-status) (focus-status dangerous))
|
|
(logclear! (-> self focus-status) (focus-status dangerous))
|
|
)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(let ((gp-0 (new 'stack-no-clear 'enemy-jump-info)))
|
|
(let ((s5-0 0))
|
|
(enemy-method-83 self gp-0)
|
|
(if (and (-> self enemy-info use-jump-blocked)
|
|
(logtest? (enemy-flag vulnerable) (-> self enemy-flags))
|
|
(enemy-method-82 self gp-0)
|
|
)
|
|
(go-virtual jump-blocked)
|
|
)
|
|
(when (logtest? (-> gp-0 flags) 1)
|
|
(until #f
|
|
(if (enemy-method-90 self s5-0 gp-0)
|
|
(goto cfg-12)
|
|
)
|
|
(enemy-method-91 self s5-0 gp-0)
|
|
(enemy-method-92 self s5-0 (the-as nav-poly gp-0))
|
|
(suspend)
|
|
(set! s5-0 1)
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
(label cfg-12)
|
|
(logclear! (-> self root-override2 status) (collide-status on-surface on-ground touch-surface))
|
|
(let ((s5-1 2))
|
|
(logior! (-> self focus-status) (focus-status in-air))
|
|
(until (enemy-method-86 self)
|
|
(+! (-> gp-0 hang-time) (- (-> self clock frame-counter) (-> self clock old-frame-counter)))
|
|
(enemy-method-90 self s5-1 gp-0)
|
|
(enemy-method-91 self s5-1 gp-0)
|
|
(enemy-method-92 self s5-1 (the-as nav-poly gp-0))
|
|
(suspend)
|
|
(set! s5-1 3)
|
|
)
|
|
)
|
|
(logclear! (-> self focus-status) (focus-status in-air))
|
|
(enemy-method-85 self)
|
|
(let ((s5-2 4))
|
|
(until #f
|
|
(if (enemy-method-90 self s5-2 gp-0)
|
|
(goto cfg-19)
|
|
)
|
|
(enemy-method-91 self s5-2 gp-0)
|
|
(enemy-method-92 self s5-2 (the-as nav-poly gp-0))
|
|
(suspend)
|
|
(set! s5-2 5)
|
|
)
|
|
)
|
|
#f
|
|
(label cfg-19)
|
|
(if (logtest? (enemy-flag alert) (-> self enemy-flags))
|
|
((lambda :behavior enemy
|
|
((arg0 enemy-jump-info))
|
|
(send-event (ppointer->process (-> self parent)) 'child-jumped)
|
|
(none)
|
|
)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(enemy-method-93 self)
|
|
(none)
|
|
)
|
|
:post (behavior ()
|
|
(let ((a1-0 (new 'stack-no-clear 'overlaps-others-params)))
|
|
(set! (-> a1-0 options) (overlaps-others-options))
|
|
(set! (-> a1-0 collide-with-filter) (-> self enemy-info overlaps-others-collide-with-filter))
|
|
(set! (-> a1-0 tlist) *touching-list*)
|
|
(find-overlapping-shapes (-> self root-override2) a1-0)
|
|
)
|
|
(enemy-simple-post)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate jump-blocked (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(none)
|
|
)
|
|
:trans (behavior ()
|
|
(when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5))
|
|
(if (logtest? (enemy-flag alert) (-> self enemy-flags))
|
|
(go-virtual jump)
|
|
(enemy-method-93 self)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(let ((v1-2 (ja-group)))
|
|
(when (not (and v1-2 (= v1-2 (-> self draw art-group data (-> self enemy-info idle-anim)))))
|
|
(ja-channel-push! 1 (seconds 0.2))
|
|
(ja :group! (-> self draw art-group data (-> self enemy-info idle-anim))
|
|
:num! (identity (rand-vu-float-range 0.0 (the float (+ (-> (ja-group) frames num-frames) -1))))
|
|
)
|
|
)
|
|
)
|
|
(let ((f30-0 (get-rand-float-range self 0.75 1.25)))
|
|
(until #f
|
|
(suspend)
|
|
(ja :num! (loop! f30-0))
|
|
)
|
|
)
|
|
#f
|
|
(none)
|
|
)
|
|
:post enemy-simple-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate hit (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(enemy-method-110 self)
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(enemy-method-135 self 0)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(local-vars (v1-37 enemy-flag) (v1-45 enemy-flag))
|
|
(ja-channel-push! 1 (seconds 0.2))
|
|
(let ((f30-0 (get-rand-float-range self 0.9 1.1)))
|
|
(ja-no-eval :group! (-> self draw art-group data (-> self enemy-info hit-anim))
|
|
:num! (seek!
|
|
(the float
|
|
(+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info hit-anim))) frames num-frames)
|
|
-1
|
|
)
|
|
)
|
|
f30-0
|
|
)
|
|
:frame-num 0.0
|
|
)
|
|
(until (ja-done? 0)
|
|
(suspend)
|
|
(ja :num! (seek! max f30-0))
|
|
)
|
|
)
|
|
(if (logtest? (-> self enemy-flags) (enemy-flag check-water))
|
|
(logior! (-> self focus-status) (focus-status dangerous))
|
|
(logclear! (-> self focus-status) (focus-status dangerous))
|
|
)
|
|
(let ((v1-36 (-> self enemy-flags)))
|
|
(if (logtest? v1-36 (enemy-flag checking-water))
|
|
(set! v1-37 (logior v1-36 (enemy-flag enable-on-active)))
|
|
(set! v1-37 (logclear v1-36 (enemy-flag enable-on-active)))
|
|
)
|
|
)
|
|
(set! (-> self enemy-flags) v1-37)
|
|
(if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest))
|
|
(set! (-> self mask) (logior (process-mask collectable) (-> self mask)))
|
|
(logclear! (-> self mask) (process-mask collectable))
|
|
)
|
|
(let ((v1-44 (-> self enemy-flags)))
|
|
(if (logtest? (enemy-flag no-initial-move-to-ground) v1-44)
|
|
(set! v1-45 (logior (enemy-flag check-water-backup) v1-44))
|
|
(set! v1-45 (logclear v1-44 (enemy-flag check-water-backup)))
|
|
)
|
|
)
|
|
(set! (-> self enemy-flags) v1-45)
|
|
(logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
|
|
(logclear! (-> self focus-status) (focus-status hit))
|
|
(go-hostile self)
|
|
(none)
|
|
)
|
|
:post enemy-simple-post
|
|
)
|
|
|
|
;; definition for method 101 of type enemy
|
|
;; WARN: Return type mismatch collide-spec vs none.
|
|
(defmethod enemy-method-101 enemy ((obj enemy))
|
|
(when (not (logtest? (enemy-flag use-trigger) (-> obj enemy-flags)))
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag use-trigger) (-> obj enemy-flags)))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag directed))
|
|
(enemy-method-124 obj)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 103 of type enemy
|
|
(defmethod enemy-method-103 enemy ((obj enemy))
|
|
(when (logtest? (enemy-flag use-trigger) (-> obj enemy-flags))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag use-trigger directed))
|
|
(enemy-method-124 obj)
|
|
)
|
|
)
|
|
|
|
;; definition for method 102 of type enemy
|
|
(defmethod enemy-method-102 enemy ((obj enemy))
|
|
#f
|
|
)
|
|
|
|
;; definition for method 100 of type enemy
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch vector vs symbol.
|
|
(defmethod enemy-method-100 enemy ((obj enemy))
|
|
(local-vars (v0-1 vector))
|
|
(with-pp
|
|
(when (not (-> obj enemy-info move-to-ground))
|
|
(enemy-method-103 obj)
|
|
(return (the-as symbol #f))
|
|
)
|
|
(when (not (logtest? (enemy-flag directed) (-> obj enemy-flags)))
|
|
(let ((s5-0 (-> obj root-override2)))
|
|
(if (logtest? (-> obj focus-status) (focus-status under-water))
|
|
(enemy-method-47 obj (-> s5-0 transv))
|
|
(+! (-> s5-0 transv y) (* (-> obj enemy-info movement-gravity) (-> pp clock seconds-per-frame)))
|
|
)
|
|
(let ((a2-0 (new 'stack-no-clear 'move-above-ground-params)))
|
|
(let ((v1-16 (-> obj enemy-info)))
|
|
(set! (-> a2-0 gnd-collide-with) (-> v1-16 recover-gnd-collide-with))
|
|
(set! (-> a2-0 popup) 8192.0)
|
|
(set! (-> a2-0 dont-move-if-overlaps?) #t)
|
|
(set! (-> a2-0 hover-if-no-ground?) (-> v1-16 hover-if-no-ground))
|
|
(set! (-> a2-0 overlaps-params options) (overlaps-others-options oo0 oo2))
|
|
(set! (-> a2-0 overlaps-params collide-with-filter) (-> v1-16 overlaps-others-collide-with-filter))
|
|
)
|
|
(set! (-> a2-0 overlaps-params tlist) *touching-list*)
|
|
(-> a2-0 overlaps-params)
|
|
(enemy-method-128 obj (-> s5-0 transv) a2-0)
|
|
)
|
|
)
|
|
)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag directed))
|
|
(if (and (enemy-method-102 obj) (zero? (logand (-> obj focus-status) (focus-status dead))))
|
|
(enemy-method-73 obj)
|
|
)
|
|
(let ((s5-1 (-> obj root-override2))
|
|
(a1-2 (new 'stack-no-clear 'collide-query))
|
|
(s3-0 (new 'stack-no-clear 'vector))
|
|
(s4-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
(set! (-> s3-0 quad) (-> s5-1 gspot-pos quad))
|
|
(set! (-> s4-0 quad) (-> s5-1 gspot-normal quad))
|
|
(the-as symbol (cond
|
|
((find-ground s5-1 a1-2 (-> obj enemy-info gnd-collide-with) 8192.0 81920.0 1024.0)
|
|
(let ((f0-4 (- (-> s5-1 trans y) (-> s5-1 gspot-pos y))))
|
|
(when (>= 409.6 (fabs f0-4))
|
|
(enemy-method-103 obj)
|
|
(return (the-as symbol #f))
|
|
v0-1
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> s5-1 gspot-pos quad) (-> s3-0 quad))
|
|
(set! v0-1 (-> s5-1 gspot-normal))
|
|
(set! (-> v0-1 quad) (-> s4-0 quad))
|
|
v0-1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 46 of type enemy
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod enemy-method-46 enemy ((obj enemy) (arg0 int))
|
|
"@abstract"
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 52 of type enemy
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod enemy-method-52 enemy ((obj enemy) (arg0 vector))
|
|
(enemy-method-50 obj arg0)
|
|
(let ((s5-0 (-> obj enemy-info)))
|
|
(case (-> obj incoming knocked-type)
|
|
(((knocked-type knocked-type-2))
|
|
(let ((f30-0 (get-rand-float-range obj 0.0 1.0)))
|
|
(vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-hard-vxz-lo) (-> s5-0 knocked-hard-vxz-hi) f30-0))
|
|
(set! (-> arg0 y) (lerp (-> s5-0 knocked-hard-vy-lo) (-> s5-0 knocked-hard-vy-hi) f30-0))
|
|
)
|
|
)
|
|
(((knocked-type knocked-type-1))
|
|
(let ((f30-1 (get-rand-float-range obj 0.0 1.0)))
|
|
(vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-medium-vxz-lo) (-> s5-0 knocked-medium-vxz-hi) f30-1))
|
|
(set! (-> arg0 y) (lerp (-> s5-0 knocked-medium-vy-lo) (-> s5-0 knocked-medium-vy-hi) f30-1))
|
|
)
|
|
)
|
|
(((knocked-type knocked-type-3))
|
|
(let ((f30-2 (get-rand-float-range obj 0.0 1.0)))
|
|
(vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-huge-vxz-lo) (-> s5-0 knocked-huge-vxz-hi) f30-2))
|
|
(set! (-> arg0 y) (lerp (-> s5-0 knocked-huge-vy-lo) (-> s5-0 knocked-huge-vy-hi) f30-2))
|
|
)
|
|
)
|
|
(((knocked-type knocked-type-4))
|
|
(vector-rotate90-around-y! arg0 arg0)
|
|
(let ((v1-9 (new 'stack-no-clear 'vector)))
|
|
(vector-! v1-9 (-> obj incoming attacker-pos) (-> obj root-override2 trans))
|
|
(set! (-> v1-9 y) 0.0)
|
|
(if (< 0.0 (vector-dot v1-9 arg0))
|
|
(vector-negate! arg0 arg0)
|
|
)
|
|
)
|
|
(let ((f30-3 (get-rand-float-range obj 0.0 1.0)))
|
|
(vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-yellow-vxz-lo) (-> s5-0 knocked-yellow-vxz-hi) f30-3))
|
|
(set! (-> arg0 y) (lerp (-> s5-0 knocked-yellow-vy-lo) (-> s5-0 knocked-yellow-vy-hi) f30-3))
|
|
)
|
|
)
|
|
(((knocked-type knocked-type-5))
|
|
(let* ((f1-2 (vector-vector-xz-distance-squared (target-pos 0) (-> obj root-override2 trans)))
|
|
(f0-26 1.0)
|
|
(f2-0 61440.0)
|
|
(f1-3 (fmin f1-2 (* f2-0 f2-0)))
|
|
(f2-3 61440.0)
|
|
(f30-5 (* (- f0-26 (/ f1-3 (* f2-3 f2-3))) (get-rand-float-range obj 0.8 1.0)))
|
|
)
|
|
(vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-red-vxz-lo) (-> s5-0 knocked-red-vxz-hi) f30-5))
|
|
(set! (-> arg0 y) (lerp (-> s5-0 knocked-red-vy-lo) (-> s5-0 knocked-red-vy-hi) f30-5))
|
|
)
|
|
)
|
|
(((knocked-type knocked-type-6))
|
|
(let* ((f1-5 (vector-vector-xz-distance-squared (target-pos 0) (-> obj root-override2 trans)))
|
|
(f0-34 1.0)
|
|
(f2-6 122880.0)
|
|
(f1-6 (fmin f1-5 (* f2-6 f2-6)))
|
|
(f2-9 122880.0)
|
|
(f30-7 (* (- f0-34 (/ f1-6 (* f2-9 f2-9))) (get-rand-float-range obj 0.8 1.0)))
|
|
)
|
|
(vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-blue-vxz-lo) (-> s5-0 knocked-blue-vxz-hi) f30-7))
|
|
(cond
|
|
((>= (the-as uint 4) (-> obj incoming blue-juggle-count))
|
|
(set! (-> arg0 y) (lerp (-> s5-0 knocked-blue-vy-lo) (-> s5-0 knocked-blue-vy-hi) f30-7))
|
|
)
|
|
(else
|
|
(if (zero? (get-rand-int obj 3))
|
|
(set! (-> arg0 y) 40960.0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(((knocked-type knocked-type-7))
|
|
(set! (-> arg0 quad) (-> obj incoming attack-direction quad))
|
|
)
|
|
(else
|
|
(let ((f30-8 (get-rand-float-range obj 0.0 1.0)))
|
|
(vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-soft-vxz-lo) (-> s5-0 knocked-soft-vxz-hi) f30-8))
|
|
(set! (-> arg0 y) (lerp (-> s5-0 knocked-soft-vy-lo) (-> s5-0 knocked-soft-vy-hi) f30-8))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 51 of type enemy
|
|
(defmethod enemy-method-51 enemy ((obj enemy))
|
|
(let ((f30-0 (quaternion-y-angle (-> obj root-override2 quat))))
|
|
(case (-> obj incoming knocked-type)
|
|
(((knocked-type knocked-type-4) (knocked-type knocked-type-6))
|
|
(let ((a0-5 (handle->process (-> obj focus handle))))
|
|
(when a0-5
|
|
(let ((v1-9 (get-trans (the-as process-focusable a0-5) 0)))
|
|
(set! f30-0
|
|
(atan (- (-> v1-9 x) (-> obj root-override2 trans x)) (- (-> v1-9 z) (-> obj root-override2 trans z)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(let* ((v1-13 (-> obj root-override2 transv))
|
|
(f28-0 (atan (-> v1-13 x) (-> v1-13 z)))
|
|
(f1-2 (deg- f30-0 f28-0))
|
|
(f2-0 (fabs f1-2))
|
|
(f0-6 (-> obj enemy-info knocked-seek-ry-clamp))
|
|
)
|
|
(when (and (< f0-6 f2-0) (< f2-0 (- 32768.0 f0-6)))
|
|
(set! f30-0 (+ (cond
|
|
((< f2-0 16384.0)
|
|
(if (>= f1-2 0.0)
|
|
f0-6
|
|
(- f0-6)
|
|
)
|
|
)
|
|
((>= f1-2 0.0)
|
|
(- 32768.0 f0-6)
|
|
)
|
|
(else
|
|
(+ -32768.0 f0-6)
|
|
)
|
|
)
|
|
f28-0
|
|
)
|
|
)
|
|
(if (< f30-0 0.0)
|
|
(set! f30-0 (+ 65536.0 f30-0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
f30-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 77 of type enemy
|
|
(defmethod enemy-method-77 enemy ((obj enemy) (arg0 (pointer float)))
|
|
(ja-channel-push! 1 0)
|
|
(let ((a1-2 (-> obj draw art-group data (-> obj enemy-info knocked-anim)))
|
|
(a0-4 (-> obj skel root-channel 0))
|
|
)
|
|
(set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2))
|
|
(set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1)))
|
|
(set! (-> a0-4 param 1) (-> arg0 0))
|
|
(set! (-> a0-4 frame-num) 0.0)
|
|
(joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for method 78 of type enemy
|
|
(defmethod enemy-method-78 enemy ((obj enemy) (arg0 (pointer float)))
|
|
(let ((v1-4 (-> obj draw art-group data (-> obj enemy-info knocked-land-anim)))
|
|
(a0-3 (-> obj skel root-channel 0))
|
|
)
|
|
(set! (-> a0-3 frame-group) (the-as art-joint-anim v1-4))
|
|
(set! (-> a0-3 param 0) (the float (+ (-> (the-as art-joint-anim v1-4) frames num-frames) -1)))
|
|
(set! (-> a0-3 param 1) (-> arg0 0))
|
|
(set! (-> a0-3 frame-num) 0.0)
|
|
(joint-control-channel-group! a0-3 (the-as art-joint-anim v1-4) num-func-seek!)
|
|
)
|
|
#t
|
|
)
|
|
|
|
;; definition for method 80 of type enemy
|
|
(defmethod enemy-method-80 enemy ((obj enemy) (arg0 enemy-knocked-info))
|
|
(let ((gp-0 (-> obj root-override2)))
|
|
(or (>= (-> arg0 on-surface-count) 3)
|
|
(and (logtest? (-> gp-0 status) (collide-status on-ground)) (>= 16384.0 (-> gp-0 transv y)))
|
|
(and (>= (-> arg0 move-count) 3)
|
|
(let ((f0-1 40.96))
|
|
(>= (* f0-1 f0-1) (vector-vector-distance-squared (-> gp-0 trans-old) (-> gp-0 trans-old-old)))
|
|
)
|
|
(let ((f0-4 40.96))
|
|
(>= (* f0-4 f0-4) (vector-vector-distance-squared (-> gp-0 trans-old-old) (-> gp-0 trans-old-old-old)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 81 of type enemy
|
|
(defmethod enemy-method-81 enemy ((obj enemy))
|
|
(let ((s5-0 (-> obj root-override2))
|
|
(a1-0 (new 'stack-no-clear 'collide-query))
|
|
(gp-0 #t)
|
|
)
|
|
(when (find-ground s5-0 a1-0 (-> obj enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0)
|
|
(let ((f0-1 (- (-> s5-0 trans y) (-> s5-0 gspot-pos y))))
|
|
(if (and (>= f0-1 -1228.8) (>= 6144.0 f0-1))
|
|
(set! gp-0 #f)
|
|
)
|
|
)
|
|
)
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 79 of type enemy
|
|
(defmethod enemy-method-79 enemy ((obj enemy) (arg0 int) (arg1 enemy-knocked-info))
|
|
(local-vars (s5-0 symbol))
|
|
(let ((v1-0 arg0))
|
|
(cond
|
|
((zero? v1-0)
|
|
(enemy-method-77 obj (the-as (pointer float) arg1))
|
|
(set! s5-0 #f)
|
|
)
|
|
((= v1-0 1)
|
|
(set! s5-0 (ja-done? 0))
|
|
(let ((a0-4 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-4 param 0) (the float (+ (-> a0-4 frame-group frames num-frames) -1)))
|
|
(set! (-> a0-4 param 1) (-> arg1 anim-speed))
|
|
(joint-control-channel-group-eval! a0-4 (the-as art-joint-anim #f) num-func-seek!)
|
|
)
|
|
)
|
|
((= v1-0 2)
|
|
(set! s5-0 (not (enemy-method-78 obj (the-as (pointer float) arg1))))
|
|
(set! (-> obj incoming blue-juggle-count) (the-as uint 0))
|
|
)
|
|
((= v1-0 3)
|
|
(set! s5-0 (ja-done? 0))
|
|
(let ((a0-9 (-> obj skel root-channel 0)))
|
|
(set! (-> a0-9 param 0) (the float (+ (-> a0-9 frame-group frames num-frames) -1)))
|
|
(set! (-> a0-9 param 1) (-> arg1 anim-speed))
|
|
(joint-control-channel-group-eval! a0-9 (the-as art-joint-anim #f) num-func-seek!)
|
|
)
|
|
)
|
|
((= v1-0 4)
|
|
(vector-reset! (-> obj root-override2 transv))
|
|
(set! s5-0 #t)
|
|
)
|
|
(else
|
|
(set! s5-0 #t)
|
|
)
|
|
)
|
|
)
|
|
s5-0
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate knocked (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(enemy-method-110 self)
|
|
(set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
|
|
(logclear! (-> self mask) (process-mask actor-pause))
|
|
(let* ((v1-8 *game-info*)
|
|
(a0-4 (+ (-> v1-8 attack-id) 1))
|
|
)
|
|
(set! (-> v1-8 attack-id) a0-4)
|
|
(set! (-> self attack-id) a0-4)
|
|
)
|
|
(enemy-method-103 self)
|
|
(if (logtest? (enemy-option knocked-into-water) (-> self fact-info-override enemy-options))
|
|
(set! (-> self enemy-flags) (logior (enemy-flag trackable-backup) (-> self enemy-flags)))
|
|
)
|
|
(let ((v1-16 (-> self root-override2)))
|
|
(logclear! (-> v1-16 status) (collide-status
|
|
on-surface
|
|
on-ground
|
|
touch-surface
|
|
touch-wall
|
|
touch-ceiling
|
|
touch-actor
|
|
on-special-surface
|
|
touch-edge
|
|
blocked
|
|
on-water
|
|
impact-surface
|
|
touch-background
|
|
stuck
|
|
glance
|
|
)
|
|
)
|
|
(when (not (logtest? (-> v1-16 root-prim prim-core action) (collide-action no-normal-reset)))
|
|
(let ((a0-16 (-> v1-16 dynam gravity-normal)))
|
|
(set! (-> v1-16 local-normal quad) (-> a0-16 quad))
|
|
(set! (-> v1-16 surface-normal quad) (-> a0-16 quad))
|
|
(set! (-> v1-16 poly-normal quad) (-> a0-16 quad))
|
|
)
|
|
(set! (-> v1-16 coverage) 0.0)
|
|
(set! (-> v1-16 touch-angle) 0.0)
|
|
)
|
|
(enemy-method-52 self (-> v1-16 transv))
|
|
)
|
|
(if (>= (-> self enemy-info knocked-seek-ry-clamp) 0.0)
|
|
(set! (-> self desired-angle) (enemy-method-51 self))
|
|
)
|
|
(if (zero? (-> self hit-points))
|
|
(enemy-method-132 self)
|
|
(enemy-method-135 self 0)
|
|
)
|
|
(logclear! (-> self focus-status) (focus-status dangerous))
|
|
(if (= (-> self incoming knocked-type) (knocked-type knocked-type-4))
|
|
(logclear! (-> self enemy-flags) (enemy-flag check-water-backup))
|
|
)
|
|
(set! (-> self root-override2 penetrate-using) (penetrate lunge vehicle knocked))
|
|
(enemy-method-49 self)
|
|
(enemy-method-46 self 1)
|
|
(none)
|
|
)
|
|
:exit (behavior ()
|
|
(local-vars (v1-1 enemy-flag) (v1-15 enemy-flag) (v1-23 enemy-flag))
|
|
(let ((v1-0 (-> self enemy-flags)))
|
|
(if (logtest? (enemy-flag enable-on-hostile) v1-0)
|
|
(set! v1-1 (logior (enemy-flag trackable-backup) v1-0))
|
|
(set! v1-1 (logclear v1-0 (enemy-flag trackable-backup)))
|
|
)
|
|
)
|
|
(set! (-> self enemy-flags) v1-1)
|
|
(when (nonzero? (-> self hit-points))
|
|
(set! (-> self root-override2 penetrate-using)
|
|
(the-as penetrate (logclear (-> self root-override2 penetrate-using) (penetrate knocked)))
|
|
)
|
|
(enemy-method-46 self 2)
|
|
(if (logtest? (-> self enemy-flags) (enemy-flag check-water))
|
|
(logior! (-> self focus-status) (focus-status dangerous))
|
|
(logclear! (-> self focus-status) (focus-status dangerous))
|
|
)
|
|
(let ((v1-14 (-> self enemy-flags)))
|
|
(if (logtest? v1-14 (enemy-flag checking-water))
|
|
(set! v1-15 (logior v1-14 (enemy-flag enable-on-active)))
|
|
(set! v1-15 (logclear v1-14 (enemy-flag enable-on-active)))
|
|
)
|
|
)
|
|
(set! (-> self enemy-flags) v1-15)
|
|
(if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest))
|
|
(set! (-> self mask) (logior (process-mask collectable) (-> self mask)))
|
|
(logclear! (-> self mask) (process-mask collectable))
|
|
)
|
|
(let ((v1-22 (-> self enemy-flags)))
|
|
(if (logtest? (enemy-flag no-initial-move-to-ground) v1-22)
|
|
(set! v1-23 (logior (enemy-flag check-water-backup) v1-22))
|
|
(set! v1-23 (logclear v1-22 (enemy-flag check-water-backup)))
|
|
)
|
|
)
|
|
(set! (-> self enemy-flags) v1-23)
|
|
(logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
|
|
(logclear! (-> self focus-status) (focus-status hit))
|
|
)
|
|
(none)
|
|
)
|
|
:trans (behavior ()
|
|
(if (>= (-> self enemy-info knocked-seek-ry-clamp) 0.0)
|
|
(seek-toward-yaw-angle! (-> self root-override2) (-> self desired-angle) 138353.78 (seconds 0.1))
|
|
)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(let ((gp-0 (new 'stack-no-clear 'enemy-knocked-info)))
|
|
(let ((s5-0 0))
|
|
(set! (-> gp-0 anim-speed) (get-rand-float-range self 0.9 1.1))
|
|
(set! (-> gp-0 on-surface-count) 0)
|
|
(set! (-> gp-0 move-count) 0)
|
|
(until (enemy-method-80 self gp-0)
|
|
(if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 2))
|
|
(enemy-method-73 self)
|
|
)
|
|
(if (logtest? (-> self root-override2 status) (collide-status on-surface))
|
|
(+! (-> gp-0 on-surface-count) 1)
|
|
)
|
|
(enemy-method-79 self s5-0 gp-0)
|
|
(suspend)
|
|
(+! (-> gp-0 move-count) 1)
|
|
(set! s5-0 1)
|
|
)
|
|
)
|
|
(let ((s5-1 2))
|
|
(set! (-> gp-0 land-can-land-time) (-> self clock frame-counter))
|
|
(until #f
|
|
(if (logtest? (-> self root-override2 status) (collide-status on-surface))
|
|
(+! (-> gp-0 on-surface-count) 1)
|
|
)
|
|
(if (enemy-method-79 self s5-1 gp-0)
|
|
(goto cfg-15)
|
|
)
|
|
(suspend)
|
|
(+! (-> gp-0 move-count) 1)
|
|
(set! s5-1 3)
|
|
(if (enemy-method-80 self gp-0)
|
|
(set! (-> gp-0 land-can-land-time) (-> self clock frame-counter))
|
|
)
|
|
)
|
|
)
|
|
#f
|
|
(label cfg-15)
|
|
(if (and (not (logtest? (enemy-flag recover) (-> self enemy-flags)))
|
|
(or (>= (- (-> self clock frame-counter) (-> gp-0 land-can-land-time)) (seconds 0.1))
|
|
(enemy-method-81 self)
|
|
(enemy-method-102 self)
|
|
)
|
|
)
|
|
(enemy-method-73 self)
|
|
)
|
|
(while (not (enemy-method-79 self 4 gp-0))
|
|
(suspend)
|
|
)
|
|
)
|
|
(enemy-method-101 self)
|
|
(cond
|
|
((or (zero? (-> self hit-points)) (nonzero? (-> self fated-time)))
|
|
(cond
|
|
((logtest? (enemy-flag recover) (-> self enemy-flags))
|
|
(set! (-> self hit-points) 0)
|
|
(let ((v1-67 (-> self root-override2 root-prim)))
|
|
(set! (-> v1-67 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-67 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(enemy-method-103 self)
|
|
(send-event self 'death-end)
|
|
(while (-> self child)
|
|
(suspend)
|
|
)
|
|
(cleanup-for-death self)
|
|
)
|
|
(else
|
|
(enemy-method-73 self)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(go-hostile self)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
:post enemy-falling-post
|
|
)
|
|
|
|
;; definition for method 132 of type enemy
|
|
(defmethod enemy-method-132 enemy ((obj enemy))
|
|
(when (not (logtest? (enemy-flag recover-applied-velocity) (-> obj enemy-flags)))
|
|
(set! (-> obj enemy-flags)
|
|
(the-as enemy-flag (logior (enemy-flag recover-applied-velocity) (-> obj enemy-flags)))
|
|
)
|
|
(enemy-method-135 obj 1)
|
|
(when (and (>= (-> obj enemy-info gem-joint) 0)
|
|
(not (logtest? (enemy-flag cam-attack-mode) (-> obj enemy-flags)))
|
|
(or (and (not (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status save))))
|
|
(-> obj entity)
|
|
)
|
|
(task-node-closed? (game-task-node city-win-introduction))
|
|
(logtest? (-> *game-info* secrets) (game-secrets hero-mode))
|
|
)
|
|
)
|
|
(set! (-> obj enemy-flags) (logior (enemy-flag cam-attack-mode) (-> obj enemy-flags)))
|
|
(remove-from-process *part-engine* obj)
|
|
(setup-masks
|
|
(-> obj draw)
|
|
(the-as int (-> obj enemy-info gem-no-seg))
|
|
(the-as int (-> obj enemy-info gem-seg))
|
|
)
|
|
(let ((a0-18 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj enemy-info gem-joint))))
|
|
)
|
|
(birth-pickup-at-point a0-18 (pickup-type gem) 1.0 #t *entity-pool* (-> obj fact-info-override))
|
|
)
|
|
)
|
|
(logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water))
|
|
(logclear! (-> obj focus-status) (focus-status dangerous))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag check-water))
|
|
(logclear! (-> obj mask) (process-mask collectable))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag look-at-move-dest))
|
|
(logclear! (-> obj mask) (process-mask actor-pause))
|
|
(logclear! (-> obj enemy-flags) (enemy-flag notice))
|
|
(logior! (-> obj focus-status) (focus-status dead))
|
|
(if (-> obj skel effect)
|
|
(logior! (-> obj skel effect flags) (effect-control-flag ecf1))
|
|
)
|
|
(enemy-method-110 obj)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(enemy-method-132 self)
|
|
(let ((v1-3 (-> self root-override2 root-prim)))
|
|
(set! (-> v1-3 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-3 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(set! (-> self state-time) (-> self clock frame-counter))
|
|
(set! (-> self hit-points) 0)
|
|
(enemy-method-103 self)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.075))
|
|
(let ((f30-0 (get-rand-float-range self 0.8 1.2)))
|
|
(ja-no-eval :group! (-> self draw art-group data (-> self enemy-info die-anim))
|
|
:num! (seek!
|
|
(the float
|
|
(+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info die-anim))) frames num-frames)
|
|
-1
|
|
)
|
|
)
|
|
f30-0
|
|
)
|
|
:frame-num 0.0
|
|
)
|
|
(until (ja-done? 0)
|
|
(suspend)
|
|
(ja :num! (seek! max f30-0))
|
|
)
|
|
)
|
|
(send-event self 'death-end)
|
|
(while (-> self child)
|
|
(suspend)
|
|
)
|
|
(cleanup-for-death self)
|
|
(none)
|
|
)
|
|
:post enemy-simple-post
|
|
)
|
|
|
|
;; definition for method 133 of type enemy
|
|
(defmethod enemy-method-133 enemy ((obj enemy))
|
|
(let ((s5-0 (-> obj root-override2))
|
|
(a1-0 (new 'stack-no-clear 'collide-query))
|
|
(gp-0 #t)
|
|
)
|
|
(when (find-ground s5-0 a1-0 (-> obj enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0)
|
|
(if (< (- (-> s5-0 trans y) (-> s5-0 gspot-pos y)) 8192.0)
|
|
(set! gp-0 #f)
|
|
)
|
|
)
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die-falling (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(enemy-method-132 self)
|
|
(let ((v1-3 (-> self root-override2 root-prim)))
|
|
(set! (-> v1-3 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-3 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(set! (-> self hit-points) 0)
|
|
(if (logtest? (enemy-option knocked-into-water) (-> self fact-info-override enemy-options))
|
|
(set! (-> self enemy-flags) (logior (enemy-flag trackable-backup) (-> self enemy-flags)))
|
|
)
|
|
(enemy-method-103 self)
|
|
(none)
|
|
)
|
|
:exit (behavior ()
|
|
(local-vars (v0-0 enemy-flag))
|
|
(let ((v1-0 (-> self enemy-flags)))
|
|
(if (logtest? (enemy-flag enable-on-hostile) v1-0)
|
|
(set! v0-0 (logior (enemy-flag trackable-backup) v1-0))
|
|
(set! v0-0 (logclear v1-0 (enemy-flag trackable-backup)))
|
|
)
|
|
)
|
|
(set! (-> self enemy-flags) v0-0)
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(ja-channel-push! 1 (seconds 0.1))
|
|
(let ((gp-0 (-> self draw art-group data (if (enemy-method-133 self)
|
|
(-> self enemy-info die-falling-anim)
|
|
(-> self enemy-info die-anim)
|
|
)
|
|
)
|
|
)
|
|
(f30-0 (get-rand-float-range self 0.8 1.2))
|
|
)
|
|
(ja-no-eval :group! gp-0
|
|
:num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0)
|
|
:frame-num 0.0
|
|
)
|
|
(until (ja-done? 0)
|
|
(suspend)
|
|
(ja :num! (seek! max f30-0))
|
|
)
|
|
)
|
|
(send-event self 'death-end)
|
|
(while (-> self child)
|
|
(suspend)
|
|
)
|
|
(cleanup-for-death self)
|
|
(none)
|
|
)
|
|
:post enemy-die-falling-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate directed (enemy)
|
|
:virtual #t
|
|
:event enemy-event-handler
|
|
:enter (behavior ()
|
|
(set! (-> self enemy-flags) (logior (enemy-flag victory) (-> self enemy-flags)))
|
|
((-> (method-of-type enemy idle) enter))
|
|
(none)
|
|
)
|
|
:exit (behavior ()
|
|
(logclear! (-> self enemy-flags) (enemy-flag victory))
|
|
(none)
|
|
)
|
|
:code (-> (method-of-type enemy idle) code)
|
|
:post (-> (method-of-type enemy idle) post)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die-fast (enemy)
|
|
:virtual #t
|
|
:code (the-as (function none :behavior enemy) nothing)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate view-anims (enemy)
|
|
:virtual #t
|
|
:enter (behavior ()
|
|
'()
|
|
(none)
|
|
)
|
|
:trans (behavior ()
|
|
'()
|
|
(none)
|
|
)
|
|
:code (behavior ()
|
|
(let ((gp-0 (-> self draw art-group)))
|
|
(until #f
|
|
(dotimes (s5-0 (-> gp-0 length))
|
|
(let ((s4-0 (-> gp-0 data s5-0)))
|
|
(when (and s4-0 (= (-> s4-0 type) art-joint-anim))
|
|
(ja-channel-set! 1)
|
|
(ja-no-eval :group! s4-0
|
|
:num! (seek! (the float (+ (-> (the-as art-joint-anim s4-0) frames num-frames) -1)))
|
|
:frame-num 0.0
|
|
)
|
|
(until (ja-done? 0)
|
|
(suspend)
|
|
(ja :num! (seek!))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
#f
|
|
(none)
|
|
)
|
|
:post (the-as (function none :behavior enemy) transform-post)
|
|
)
|
|
|
|
;; definition for function ja-group-index?
|
|
(defbehavior ja-group-index? enemy ((arg0 int))
|
|
(ja-group? (-> self draw art-group data arg0))
|
|
)
|