67011 lines
2.6 MiB
67011 lines
2.6 MiB
;; All Types
|
|
|
|
;; TODO - some of these are likely not needed / copied from jak 2
|
|
|
|
;; type system setup
|
|
(define-extern object type)
|
|
(define-extern type type)
|
|
(define-extern structure type)
|
|
(define-extern uint128 type)
|
|
(define-extern basic type)
|
|
(define-extern pair type)
|
|
(define-extern array type)
|
|
(define-extern symbol type)
|
|
(define-extern binteger type)
|
|
(define-extern number type)
|
|
(define-extern integer type)
|
|
(define-extern uinteger type)
|
|
(define-extern float type)
|
|
(define-extern boolean type) ;; not actually added as a runtime type in jak2, but valid? supports it.
|
|
(define-extern uint16 type)
|
|
(define-extern uint32 type)
|
|
(define-extern int32 type)
|
|
(define-extern int64 type)
|
|
(define-extern uint8 type)
|
|
(define-extern uint64 type)
|
|
(define-extern process-tree type)
|
|
(define-extern process type)
|
|
(define-extern stack-frame type)
|
|
(define-extern global kheap)
|
|
(define-extern kheap type)
|
|
(define-extern pointer type)
|
|
|
|
(define-extern #t symbol)
|
|
(define-extern #f symbol)
|
|
|
|
;; some types we need.
|
|
(declare-type sparticle-launch-group basic)
|
|
(declare-type lightning-spec basic)
|
|
(declare-type sparticle-launcher basic)
|
|
(declare-type state basic)
|
|
(declare-type res-lump basic)
|
|
|
|
;; kernel types
|
|
(defenum link-flag
|
|
:bitfield #t
|
|
:type int32
|
|
(output-load-msg 0)
|
|
(output-load-true-msg 1)
|
|
(execute-login 2)
|
|
(print-login 3)
|
|
(force-debug 4)
|
|
(fast-link 5)
|
|
)
|
|
|
|
(defenum language-enum
|
|
:type int64
|
|
(english)
|
|
(french)
|
|
(german)
|
|
(spanish)
|
|
(italian)
|
|
(japanese)
|
|
(korean)
|
|
(uk-english)
|
|
)
|
|
|
|
(define-extern *debug-segment* symbol)
|
|
(define-extern nothing (function none))
|
|
(define-extern _format (function _varargs_ object))
|
|
(define-extern method-set! (function type int object none)) ;; may actually return function.
|
|
(define-extern malloc (function symbol int pointer))
|
|
(define-extern kmemopen (function kheap string none))
|
|
(define-extern kmemclose (function none))
|
|
(define-extern dgo-load (function string kheap link-flag int none))
|
|
(define-extern *listener-function* (function object))
|
|
(define-extern *enable-method-set* int)
|
|
|
|
(declare-type cpad-info basic)
|
|
(declare-type mouse-info basic)
|
|
(define-extern cpad-open (function cpad-info int cpad-info))
|
|
(define-extern cpad-get-data (function cpad-info cpad-info))
|
|
(define-extern scf-get-territory (function int)) ;; not actually a scf function...
|
|
(define-extern mouse-get-data (function mouse-info none))
|
|
(define-extern file-stream-open (function file-stream string symbol file-stream))
|
|
(define-extern file-stream-close (function file-stream file-stream))
|
|
(define-extern file-stream-length (function file-stream int))
|
|
(define-extern file-stream-seek (function file-stream int int int))
|
|
(define-extern file-stream-read (function file-stream pointer int int))
|
|
(define-extern file-stream-write (function file-stream pointer uint uint))
|
|
(define-extern reset-path (function none))
|
|
(define-extern flush-cache (function int none))
|
|
(define-extern gs-store-image (function object object object))
|
|
(define-extern sync-path (function int int int))
|
|
(define-extern file-stream-write (function file-stream pointer uint uint))
|
|
(define-extern file-stream-close (function file-stream file-stream))
|
|
(define-extern new-dynamic-structure (function symbol type int structure))
|
|
(define-extern kernel-shutdown (function none))
|
|
(define-extern scf-get-timeout (function int))
|
|
(define-extern scf-get-inactive-timeout (function int))
|
|
(define-extern syncv (function int int))
|
|
(define-extern string->symbol (function string symbol))
|
|
(define-extern link-begin (function pointer (pointer uint8) int kheap link-flag int))
|
|
(define-extern link-resume (function int))
|
|
(define-extern link-reset (function none))
|
|
(define-extern kset-language (function language-enum int))
|
|
(define-extern reset-graph (function int int int int none))
|
|
|
|
(declare-type sql-result basic)
|
|
(define-extern sql-query (function string sql-result))
|
|
|
|
(define-extern loading-level kheap)
|
|
(define-extern dma-sync (function pointer int int int))
|
|
(define-extern unload (function string none))
|
|
|
|
|
|
|
|
(defenum kmalloc-flags
|
|
:bitfield #t
|
|
(align-16 4)
|
|
(align-64 6)
|
|
(align-256 8)
|
|
(memset 12)
|
|
(top 13)
|
|
)
|
|
|
|
(define-extern kmalloc (function kheap int kmalloc-flags string pointer))
|
|
|
|
(define-extern *kernel-boot-message* symbol)
|
|
(define-extern *kernel-boot-art-group* string)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gcommon ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vec4s (uint128)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
(deftype vector (structure)
|
|
((data float 4 :score -1 :offset-assert 0) ;; guessed by decompiler
|
|
(x float :offset 0)
|
|
(y float :offset 4)
|
|
(z float :offset 8)
|
|
(w float :offset 12)
|
|
(quad uint128 :score -1 :offset 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|
|
#|
|
|
(deftype bfloat (basic)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
;; Failed to read fields.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype inline-array-class (basic)
|
|
()
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
;; Failed to read fields.
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(inline-array-class-method-9 () none) ;; 9
|
|
(inline-array-class-method-10 () none) ;; 10
|
|
(inline-array-class-method-11 () none) ;; 11
|
|
(inline-array-class-method-12 () none) ;; 12
|
|
(inline-array-class-method-13 () none) ;; 13
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype inline-array-class-uint64 (inline-array-class)
|
|
((length int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype inline-array-class-uint32 (inline-array-class)
|
|
((length int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype array (UNKNOWN)
|
|
((allocated-length int32 :offset-assert 4)
|
|
(length int32 :offset-assert 0)
|
|
(content-type type :offset-assert 8) ;; guessed by decompiler
|
|
(data uint8 :dynamic :offset-assert 12) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern identity function) ;; (function object object)
|
|
;; (define-extern 1/ function) ;; (function float float)
|
|
;; (define-extern + function) ;; (function int int int)
|
|
;; (define-extern - function) ;; (function int int int)
|
|
;; (define-extern * function) ;; (function int int int)
|
|
;; (define-extern / function) ;; (function int int int)
|
|
;; (define-extern ash function) ;; (function int int int)
|
|
;; (define-extern mod function) ;; (function int int int)
|
|
;; (define-extern rem function) ;; (function int int int)
|
|
;; (define-extern abs function) ;; (function int int)
|
|
;; (define-extern min function) ;; (function int int int)
|
|
;; (define-extern max function) ;; (function int int int)
|
|
;; (define-extern logior function) ;; (function int int int)
|
|
;; (define-extern logand function) ;; (function int int int)
|
|
;; (define-extern lognor function) ;; (function int int int)
|
|
;; (define-extern logxor function) ;; (function int int int)
|
|
;; (define-extern lognot function) ;; (function int int)
|
|
;; (define-extern false-func function) ;; (function symbol)
|
|
;; (define-extern true-func function) ;; (function symbol)
|
|
;; (define-extern format object) ;; (function _varargs_ object)
|
|
;; (define-extern basic-type? function) ;; (function basic type symbol)
|
|
;; (define-extern type-type? function) ;; (function type type symbol)
|
|
;; (define-extern type? function) ;; (function object type symbol)
|
|
;; (define-extern find-parent-method function) ;; (function type int function)
|
|
;; (define-extern ref& function)
|
|
;; (define-extern ref function) ;; (function object int object)
|
|
;; (define-extern last function) ;; (function object object)
|
|
;; (define-extern member function) ;; (function object object object)
|
|
;; (define-extern nmember function) ;; (function basic object object)
|
|
;; (define-extern assoc function) ;; (function object object object)
|
|
;; (define-extern assoce function) ;; (function object object object)
|
|
;; (define-extern nassoc function) ;; (function string object object)
|
|
;; (define-extern nassoce function) ;; (function string object object)
|
|
;; (define-extern append! function) ;; (function object object object)
|
|
;; (define-extern delete! function) ;; (function object object pair)
|
|
;; (define-extern delete-car! function) ;; (function object object object)
|
|
;; (define-extern insert-cons! function) ;; (function object object pair)
|
|
;; (define-extern sort function) ;; (function pair (function object object object) pair)
|
|
;; (define-extern string->symbol-debug function)
|
|
;; (define-extern symbol->string-debug function)
|
|
;; (define-extern symbol->hash function)
|
|
;; (define-extern mem-copy! function) ;; (function pointer pointer int pointer)
|
|
;; (define-extern qmem-copy<-! function) ;; (function pointer pointer int pointer)
|
|
;; (define-extern qmem-copy->! function) ;; (function pointer pointer int pointer)
|
|
;; (define-extern qmem-clear! function)
|
|
;; (define-extern mem-set32! function) ;; (function pointer int int pointer)
|
|
;; (define-extern mem-or! function) ;; (function pointer pointer int pointer)
|
|
;; (define-extern quad-copy! function) ;; (function pointer pointer int none)
|
|
;; (define-extern fact function) ;; (function int int)
|
|
;; (define-extern *print-column* object) ;; binteger
|
|
;; (define-extern print function) ;; (function object object)
|
|
;; (define-extern printl function) ;; (function object object)
|
|
;; (define-extern inspect function) ;; (function object object)
|
|
;; (define-extern mem-print function) ;; (function (pointer uint32) int symbol)
|
|
;; (define-extern *trace-list* object) ;; pair
|
|
;; (define-extern print-tree-bitmask function) ;; (function int int symbol)
|
|
;; (define-extern breakpoint-range-set! function) ;; (function uint uint uint int)
|
|
;; (define-extern valid? function) ;; (function object type string symbol object symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gstring ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern copy-string<-string function) ;; (function string string string)
|
|
;; (define-extern string= function) ;; (function string string symbol)
|
|
;; (define-extern string-prefix= function) ;; (function string string symbol)
|
|
;; (define-extern charp-prefix= function) ;; (function (pointer uint8) (pointer uint8) symbol)
|
|
;; (define-extern string-suffix= function) ;; (function string string symbol)
|
|
;; (define-extern string-position function) ;; (function string string int)
|
|
;; (define-extern string-charp= function) ;; (function string (pointer uint8) symbol)
|
|
;; (define-extern name= function) ;; (function object object symbol)
|
|
;; (define-extern copyn-string<-charp function) ;; (function string (pointer uint8) int string)
|
|
;; (define-extern string<-charp function) ;; (function string (pointer uint8) string)
|
|
;; (define-extern charp<-string function) ;; (function (pointer uint8) string int)
|
|
;; (define-extern copyn-charp<-string function) ;; (function (pointer uint8) string int none)
|
|
;; (define-extern copy-charp<-charp function) ;; (function (pointer uint8) (pointer uint8) (pointer uint8))
|
|
;; (define-extern cat-string<-string function) ;; (function string string string)
|
|
;; (define-extern catn-string<-charp function) ;; (function string (pointer uint8) int string)
|
|
;; (define-extern cat-string<-string_to_charp function) ;; (function string string (pointer uint8) (pointer uint8))
|
|
;; (define-extern append-character-to-string function) ;; (function string uint8 int)
|
|
;; (define-extern charp-basename function) ;; (function (pointer uint8) (pointer uint8))
|
|
;; (define-extern clear function) ;; (function string string)
|
|
;; (define-extern string<? function) ;; (function string string symbol)
|
|
;; (define-extern string>? function) ;; (function string string symbol)
|
|
;; (define-extern string<=? function) ;; (function string string symbol)
|
|
;; (define-extern string>=? function) ;; (function string string symbol)
|
|
;; (define-extern *string-tmp-str* object) ;; string
|
|
;; (define-extern string-skip-to-char function) ;; (function (pointer uint8) uint (pointer uint8))
|
|
;; (define-extern string-cat-to-last-char function) ;; (function string string uint (pointer uint8))
|
|
;; (define-extern string-skip-whitespace function) ;; (function (pointer uint8) (pointer uint8))
|
|
;; (define-extern string-suck-up! function) ;; (function string (pointer uint8) symbol)
|
|
;; (define-extern string-strip-leading-whitespace! function) ;; (function string symbol)
|
|
;; (define-extern string-strip-trailing-whitespace! function) ;; (function string symbol)
|
|
;; (define-extern string-strip-whitespace! function) ;; (function string symbol)
|
|
;; (define-extern string-upcase function) ;; (function string string none)
|
|
;; (define-extern string-get-arg!! function) ;; (function string string symbol)
|
|
;; (define-extern string->int function) ;; (function string int)
|
|
;; (define-extern string->float function) ;; (function string float)
|
|
;; (define-extern string-get-int32!! function) ;; (function (pointer int32) string symbol)
|
|
;; (define-extern string-get-float!! function) ;; (function (pointer float) string symbol)
|
|
;; (define-extern string-get-flag!! function) ;; (function (pointer symbol) string string string symbol)
|
|
;; (define-extern string-word-wrap function) ;; (function string int none)
|
|
;; (define-extern *debug-draw-pauseable* object) ;; symbol
|
|
;; (define-extern *stdcon0* object) ;; string
|
|
;; (define-extern *stdcon1* object) ;; string
|
|
;; (define-extern *null* object)
|
|
;; (define-extern *stdcon* object) ;; string
|
|
;; (define-extern *stdebug* object)
|
|
;; (define-extern *temp-string* object) ;; string
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; oasis-defense ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype oasis-point (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype oasis-vehicle (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(path-type int8 :offset-assert 8)
|
|
(path-pos int8 :offset-assert 9)
|
|
(spawned-marauder? basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype oasis-marauder (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(initialized? basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-oasis-defense (task-manager)
|
|
((nav-mesh basic :offset-assert 240)
|
|
(vehicle UNKNOWN 3 :offset-assert 248)
|
|
(vehicle-count uint8 :offset-assert 296)
|
|
(v-free-list basic :offset-assert 300)
|
|
(marauder UNKNOWN 7 :offset-assert 304)
|
|
(m-free-list basic :offset-assert 416)
|
|
(marauder-count uint8 :offset-assert 420)
|
|
(total-spawned uint8 :offset-assert 421)
|
|
(total-veh-spawned uint8 :offset-assert 422)
|
|
(check-timer uint64 :offset-assert 424)
|
|
(trans-timer uint64 :offset-assert 432)
|
|
(veh-fx UNKNOWN 2 :offset-assert 440)
|
|
(veh-fx-timer uint64 :offset-assert 456)
|
|
(ash-entity basic :offset-assert 464)
|
|
(marauder-entity basic :offset-assert 468)
|
|
(last-kill-time uint64 :offset-assert 472)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x1e0
|
|
:flag-assert #x24016001e0
|
|
(:methods
|
|
(task-manager-desert-oasis-defense-method-32 () none) ;; 32
|
|
(task-manager-desert-oasis-defense-method-33 () none) ;; 33
|
|
(task-manager-desert-oasis-defense-method-34 () none) ;; 34
|
|
(task-manager-desert-oasis-defense-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desoasis-hellcat (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
idle ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *oasis-marauder-start* array)
|
|
;; (define-extern *oasis-vehicle-start* array)
|
|
;; (define-extern *oasis-vehicle-path* array)
|
|
;; (define-extern *oasis-vehicle-fx-path* array)
|
|
;; (define-extern *oasis-marauder-spawn-point* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; loader-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype load-dir (basic)
|
|
;; ()
|
|
;; :flag-assert #xb00000010
|
|
;; )
|
|
|
|
;; (deftype load-dir-art-group (load-dir)
|
|
;; ()
|
|
;; :flag-assert #xb00000010
|
|
;; )
|
|
|
|
#|
|
|
(deftype external-art-buffer (basic)
|
|
((index int32 :offset-assert 4)
|
|
(other external-art-buffer :offset-assert 8) ;; guessed by decompiler
|
|
(status symbol :offset-assert 12) ;; guessed by decompiler
|
|
(locked? symbol :offset-assert 16) ;; guessed by decompiler
|
|
(login? symbol :offset-assert 20) ;; guessed by decompiler
|
|
(frame-lock symbol :offset-assert 24) ;; guessed by decompiler
|
|
(init-heap (function external-art-buffer object) :offset-assert 28) ;; guessed by decompiler
|
|
(heap kheap :inline :offset-assert 32)
|
|
(pending-load-file string :offset-assert 48) ;; guessed by decompiler
|
|
(pending-load-file-part int32 :offset-assert 52)
|
|
(pending-load-file-owner uint64 :offset-assert 56) ;; handle
|
|
(pending-load-file-priority float :offset-assert 64)
|
|
(load-file string :offset-assert 68) ;; guessed by decompiler
|
|
(load-file-part int32 :offset-assert 72)
|
|
(load-file-owner uint64 :offset-assert 80) ;; handle
|
|
(load-file-priority float :offset-assert 88)
|
|
(buf pointer :offset-assert 92) ;; guessed by decompiler
|
|
(len int32 :offset-assert 96)
|
|
(art-group art-group :offset-assert 100) ;; guessed by decompiler
|
|
(art-data uint32 :offset-assert 100)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x68
|
|
:flag-assert #x1000000068
|
|
(:methods
|
|
;; (new (symbol type int function symbol) _type_ 0)
|
|
(external-art-buffer-method-9 () none) ;; 9 ;; (set-pending-file (_type_ string int handle float) int 9)
|
|
(external-art-buffer-method-10 () none) ;; 10 ;; (update (_type_) int 10)
|
|
(external-art-buffer-method-11 () none) ;; 11 ;; (inactive? (_type_) symbol 11)
|
|
(external-art-buffer-method-12 () none) ;; 12 ;; (file-status (_type_ string int) symbol 12)
|
|
(external-art-buffer-method-13 () none) ;; 13 ;; (link-file (_type_ art-group) art-group 13)
|
|
(external-art-buffer-method-14 () none) ;; 14 ;; (unlink-file (_type_ art-group) int 14)
|
|
(external-art-buffer-method-15 () none) ;; 15 ;; (unlock! (_type_) int 15)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spool-anim (basic)
|
|
((name string :offset-assert 16) ;; guessed by decompiler
|
|
(anim-name basic :offset-assert 20)
|
|
(parts int32 :offset-assert 24)
|
|
(hint-id int32 :offset-assert 24)
|
|
(priority float :offset-assert 28)
|
|
(owner uint64 :offset-assert 32) ;; handle
|
|
(command-list pair :offset-assert 40) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype external-art-control (basic)
|
|
((buffer external-art-buffer 2 :offset-assert 4) ;; guessed by decompiler
|
|
(rec spool-anim 3 :offset-assert 20) ;; guessed by decompiler
|
|
(spool-lock uint64 :offset-assert 160) ;; handle
|
|
(reserve-buffer external-art-buffer :offset-assert 168) ;; guessed by decompiler
|
|
(reserve-buffer-count int16 :offset-assert 172)
|
|
(dma-reserve-buffer-count int16 :offset-assert 174)
|
|
(active-stream string :offset-assert 176) ;; guessed by decompiler
|
|
(queue-stream (array spool-anim) :offset-assert 180) ;; guessed by decompiler
|
|
(frame-mask uint32 :offset-assert 184)
|
|
(dma-reserve-heap kheap :inline :offset-assert 192)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xd0
|
|
:flag-assert #x10000000d0
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(external-art-control-method-9 () none) ;; 9 ;; (update (_type_ symbol) int 9)
|
|
(external-art-control-method-10 () none) ;; 10 ;; (clear-rec (_type_) int 10)
|
|
(external-art-control-method-11 () none) ;; 11 ;; (spool-push (_type_ string int process float) int 11)
|
|
(external-art-control-method-12 () none) ;; 12 ;; (file-status (_type_ string int) symbol 12)
|
|
(external-art-control-method-13 () none) ;; 13 ;; (reserve-alloc (_type_) kheap 13)
|
|
(external-art-control-method-14 () none) ;; 14 ;; (reserve-free (_type_ kheap) int 14)
|
|
(external-art-control-method-15 () none) ;; 15 ;; (none-reserved? (_type_) symbol 15)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype subtitle-range (basic)
|
|
((start-frame float :offset-assert 4)
|
|
(end-frame float :offset-assert 8)
|
|
(message basic 12 :offset-assert 12) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype subtitle-image (basic)
|
|
((width uint16 :offset-assert 4)
|
|
(height uint16 :offset-assert 6)
|
|
(palette rgba 16 :offset-assert 16) ;; guessed by decompiler
|
|
(data uint8 :dynamic :offset-assert 80) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; viewer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype viewer (process-drawable)
|
|
((janim art-joint-anim :offset-assert 200) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #xcc
|
|
:flag-assert #x14005000cc
|
|
(:states
|
|
viewer-process ;; associated process guessed by decompiler, old: (state viewer)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *viewer-sg* skeleton-group) ;; skeleton-group
|
|
;; (define-extern viewer-string object) ;; string
|
|
;; (define-extern viewer-ja-name object) ;; string
|
|
;; (define-extern viewer-geo-name object) ;; string
|
|
;; (define-extern actor-get-arg! function) ;; (function string string string symbol)
|
|
;; (define-extern art-part-name function) ;; (function string string)
|
|
;; (define-extern init-viewer function) ;; (function string string none :behavior viewer)
|
|
;; (define-extern init-viewer-for-other function) ;; (function string vector entity-actor none :behavior viewer)
|
|
;; (define-extern add-a-bunch function) ;; (function string int int float process-tree entity-actor symbol)
|
|
;; (define-extern birth-viewer function) ;; (function process entity-actor object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype gs-pmode (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-smode2 (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-display-fb (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-display (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-bgcolor (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-csr (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
#|
|
|
(deftype gs-bank (structure)
|
|
((pmode uint64 :offset-assert 0) ;; gs-pmode
|
|
(smode2 uint64 :offset-assert 32) ;; gs-smode2
|
|
(dspfb1 uint64 :offset-assert 112) ;; gs-display-fb
|
|
(display1 uint64 :offset-assert 128) ;; gs-display
|
|
(dspfb2 uint64 :offset-assert 144) ;; gs-display-fb
|
|
(display2 uint64 :offset-assert 160) ;; gs-display
|
|
(extbuf uint64 :offset-assert 176)
|
|
(extdata uint64 :offset-assert 192)
|
|
(extwrite uint64 :offset-assert 208)
|
|
(bgcolor uint64 :offset-assert 224) ;; gs-bgcolor
|
|
(csr uint64 :offset-assert 4096) ;; gs-csr
|
|
(imr uint64 :offset-assert 4112)
|
|
(busdir uint64 :offset-assert 4160)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1048
|
|
:flag-assert #x900001048
|
|
)
|
|
|#
|
|
|
|
;; (deftype gs-frame (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-zbuf (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-xy-offset (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-scissor (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-prmode-cont (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-color-clamp (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-dthe (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-test (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-prim (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-rgbaq (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-xyz (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-uv (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-st (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-xyzf (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
#|
|
|
(deftype gs-adcmd (structure)
|
|
((word uint32 4 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
(data uint64 :offset-assert 0)
|
|
(cmds uint64 :offset-assert 8) ;; gs-reg64
|
|
(cmd uint8 :offset-assert 8)
|
|
(x uint32 :offset-assert 0)
|
|
(y uint32 :offset-assert 4)
|
|
(z uint32 :offset-assert 8)
|
|
(w uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (deftype gs-trxpos (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-trxreg (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-trxdir (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-bitbltbuf (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-tex0 (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-tex1 (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-texa (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-texclut (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
;; (deftype gs-miptbp (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
#|
|
|
(deftype gs-alpha (uint64)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (deftype gs-clamp (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
#|
|
|
(deftype gs-fog (uint64)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gs-fogcol (uint64)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (deftype gif-ctrl (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype gif-mode (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype gif-stat (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype gif-cnt (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype gif-p3cnt (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype gif-p3tag (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
#|
|
|
(deftype gif-bank (structure)
|
|
((ctrl gif-ctrl :offset-assert 0) ;; guessed by decompiler
|
|
(mode gif-mode :offset-assert 16) ;; guessed by decompiler
|
|
(stat gif-stat :offset-assert 32) ;; guessed by decompiler
|
|
(tag0 uint32 :offset-assert 64)
|
|
(tag1 uint32 :offset-assert 80)
|
|
(tag2 uint32 :offset-assert 96)
|
|
(tag3 uint32 :offset-assert 112)
|
|
(cnt gif-cnt :offset-assert 128) ;; guessed by decompiler
|
|
(p3cnt gif-p3cnt :offset-assert 144) ;; guessed by decompiler
|
|
(p3tag gif-p3tag :offset-assert 160) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa4
|
|
:flag-assert #x9000000a4
|
|
)
|
|
|#
|
|
|
|
;; (deftype gif-tag-prim (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype gif-tag-count (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype gif-tag64 (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
#|
|
|
(deftype gif-tag (uint128)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gs-gif-tag (structure)
|
|
((qword qword :inline :offset-assert 0) ;; uint128
|
|
(dword uint64 2 :offset-assert 0) ;; guessed by decompiler
|
|
(word uint32 4 :offset-assert 0) ;; guessed by decompiler
|
|
(tag uint64 :offset-assert 0) ;; gif-tag64
|
|
(regs uint64 :offset-assert 8) ;; gif-tag-regs
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gif-packet (basic)
|
|
((reg-count int32 :offset-assert 4)
|
|
(gif-tag0 uint128 :offset-assert 16)
|
|
(args uint64 1 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype draw-context (basic)
|
|
((orgx int32 :offset-assert 4)
|
|
(orgy int32 :offset-assert 8)
|
|
(orgz int32 :offset-assert 12)
|
|
(width int32 :offset-assert 16)
|
|
(height int32 :offset-assert 20)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gs-packed-rgba (vector4w)
|
|
((r int32 :offset-assert 0)
|
|
(g int32 :offset-assert 4)
|
|
(b int32 :offset-assert 8)
|
|
(a int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gs-packed-xyzw (vector)
|
|
((ix int32 :offset-assert 0)
|
|
(iy int32 :offset-assert 4)
|
|
(iz int32 :offset-assert 8)
|
|
(iw int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gs-packed-stq (vector)
|
|
((tex-s float :offset-assert 0)
|
|
(tex-t float :offset-assert 4)
|
|
(tex-q float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gs-packed-uv (vector)
|
|
((u int16 :offset-assert 0)
|
|
(v int16 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gs-packed-gt (structure)
|
|
((stq gs-packed-stq :inline :offset-assert 0)
|
|
(rgba gs-packed-rgba :inline :offset-assert 16)
|
|
(xyzw gs-packed-xyzw :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gs-packed-gt4 (structure)
|
|
((data gs-packed-gt 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc0
|
|
:flag-assert #x9000000c0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern psm-size function) ;; (function gs-psm int)
|
|
;; (define-extern psm-page-height function) ;; (function gs-psm int)
|
|
;; (define-extern psm->string function) ;; (function gs-psm string)
|
|
;; (define-extern *fog-color* object) ;; rgba
|
|
;; (define-extern open-gif-packet function) ;; (function gif-packet gif-packet)
|
|
;; (define-extern add-reg-gif-packet function) ;; (function gif-packet int int none)
|
|
;; (define-extern close-gif-packet function) ;; (function gif-packet int gif-packet)
|
|
;; (define-extern draw-context-set-xy function) ;; (function draw-context int int none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-vu1 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern generic-vu1-block object) ;; vu-function
|
|
;; (define-extern generic-setup-constants function) ;; (function generic-constants none)
|
|
;; (define-extern generic-add-constants function) ;; (function dma-buffer none)
|
|
;; (define-extern generic-setup-shrub-constants function)
|
|
;; (define-extern generic-add-shrub-constants function) ;; (function dma-buffer int int int none)
|
|
;; (define-extern generic-init-buf function) ;; (function dma-buffer gs-zbuf none)
|
|
;; (define-extern generic-vu1-init-buf function) ;; (function bucket-id gs-zbuf none)
|
|
;; (define-extern generic-vu1-init-buf-special function) ;; (function bucket-id gs-zbuf none)
|
|
;; (define-extern generic-vu1-init-buffers function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern sphere-cull function) ;; (function vector symbol)
|
|
;; (define-extern guard-band-cull function) ;; (function vector symbol)
|
|
;; (define-extern sphere-in-view-frustum? function) ;; (function sphere symbol)
|
|
;; (define-extern line-in-view-frustum? function) ;; (function vector vector symbol)
|
|
;; (define-extern vis-cull function) ;; (function int symbol)
|
|
;; (define-extern vis-cull-debug function) ;; (function work-area int symbol)
|
|
;; (define-extern error-sphere function) ;; (function drawable-error string none)
|
|
;; (define-extern *edit-instance* object) ;; string
|
|
;; (define-extern *instance-mem-usage* object) ;; memory-usage-block
|
|
;; (define-extern find-instance-by-name-level function) ;; (function string level prototype-bucket)
|
|
;; (define-extern find-instance-by-name function) ;; (function string prototype-bucket)
|
|
;; (define-extern prototypes-game-visible-set! function) ;; (function pair symbol int)
|
|
;; (define-extern find-instance-by-index function) ;; (function type int bsp-header prototype-bucket)
|
|
;; (define-extern prototype-bucket-type function) ;; (function prototype-bucket type)
|
|
;; (define-extern prototype-bucket-recalc-fields function) ;; (function prototype-bucket prototype-bucket)
|
|
;; (define-extern print-prototype-list function) ;; (function none)
|
|
;; (define-extern draw-instance-info function) ;; (function string none)
|
|
;; (define-extern set-shadow-by-name function) ;; (function string int int none)
|
|
;; (define-extern get-shadow-by-name function) ;; (function string none)
|
|
;; (define-extern teleport-camera-by-name function) ;; (function string none)
|
|
;; (define-extern teleport-camera-by-pos function)
|
|
;; (define-extern calc-vu1-shadow function)
|
|
;; (define-extern calc-shadow-masks function)
|
|
;; (define-extern calc-realtime-lights function)
|
|
;; (define-extern calc-vu1-lights function)
|
|
;; (define-extern dma-add-process-drawable function) ;; (function process-drawable draw-control symbol dma-buffer none)
|
|
;; (define-extern *hud-lights* object) ;; vu-lights
|
|
;; (define-extern dma-add-process-drawable-hud function) ;; (function process-drawable draw-control float dma-buffer none)
|
|
;; (define-extern add-process-drawable function) ;; (function process-drawable draw-control symbol dma-buffer none)
|
|
;; (define-extern foreground-engine-execute function) ;; (function engine display-frame none)
|
|
;; (define-extern main-debug-hook function) ;; (function none)
|
|
;; (define-extern *debug-hook* object) ;; pair
|
|
;; (define-extern *add-sphere* object) ;; symbol
|
|
;; (define-extern *generic-effect-mode* object) ;; int
|
|
;; (define-extern foreground-initialize-engines function) ;; (function none)
|
|
;; (define-extern foreground-execute-cpu-vu0-engines function) ;; (function none)
|
|
;; (define-extern real-main-draw-hook function) ;; (function none)
|
|
;; (define-extern main-draw-hook function) ;; (function none)
|
|
;; (define-extern *draw-hook* object) ;; (function none)
|
|
;; (define-extern default-init-buffer function) ;; (function bucket-id gs-zbuf gs-test none)
|
|
;; (define-extern default-end-buffer function) ;; (function bucket-id gs-zbuf gs-test none)
|
|
;; (define-extern screen-shot-scale function) ;; (function int string none)
|
|
;; (define-extern screen-shot function) ;; (function none)
|
|
;; (define-extern display-frame-start function) ;; (function display int float none)
|
|
;; (define-extern display-frame-finish function) ;; (function display display)
|
|
;; (define-extern determine-pause-mode function) ;; (function int)
|
|
;; (define-extern calc-ratio function)
|
|
;; (define-extern display-sync function) ;; (function display none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rubble-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-func-match-part-def function)
|
|
;; (define-extern spt-func-part-rub-elec-gate function)
|
|
;; (define-extern rub-elec-gate-adjust-particles function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gkernel-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(declare-type process-tree basic)
|
|
(declare-type process process-tree)
|
|
(declare-type thread basic)
|
|
(declare-type cpu-thread thread)
|
|
(declare-type clock basic)
|
|
(declare-type res-lump basic)
|
|
(declare-type entity res-lump)
|
|
(declare-type entity-actor entity)
|
|
(declare-type event-message-block structure)
|
|
(declare-type level basic)
|
|
|
|
(defenum process-mask
|
|
:type uint32
|
|
:bitfield #t
|
|
(execute 0)
|
|
(freeze 1)
|
|
(pause 2)
|
|
(menu 3)
|
|
(progress 4)
|
|
(actor-pause 5)
|
|
(sleep 6)
|
|
(sleep-code 7)
|
|
(process-tree 8)
|
|
(heap-shrunk 9)
|
|
(going 10)
|
|
(kernel-run 11)
|
|
(no-kill 12)
|
|
(movie 13)
|
|
(dark-effect 14)
|
|
(target 15)
|
|
(sidekick 16)
|
|
(crate 17)
|
|
(bit18 18) ;; unused?
|
|
(enemy 19)
|
|
(camera 20)
|
|
(platform 21)
|
|
(ambient 22)
|
|
(entity 23)
|
|
(projectile 24)
|
|
(bot 25)
|
|
(collectable 26)
|
|
(death 27)
|
|
(no-track 28)
|
|
(guard 29)
|
|
(vehicle 30)
|
|
(civilian 31))
|
|
|
|
(deftype process-tree (basic)
|
|
((name string :offset-assert 4)
|
|
(mask process-mask :offset-assert 8)
|
|
(clock clock :offset-assert 12) ;; guessed by decompiler
|
|
(parent (pointer process-tree) :offset-assert 16) ;; guessed by decompiler
|
|
(brother (pointer process-tree) :offset-assert 20) ;; guessed by decompiler
|
|
(child (pointer process-tree) :offset-assert 24) ;; guessed by decompiler
|
|
(ppointer (pointer process) :offset-assert 28)
|
|
(self process-tree :offset-assert 32)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x24
|
|
:flag-assert #xe00000024
|
|
:no-runtime-type
|
|
(:methods
|
|
;; (new (symbol type string) _type_ 0)
|
|
(process-tree-method-9 () none) ;; 9 ;; (activate (_type_ process-tree basic pointer) process-tree 9)
|
|
(process-tree-method-10 () none) ;; 10 ;; (deactivate (_type_) none 10)
|
|
(process-tree-method-11 () none) ;; 11 ;; (init-from-entity! (_type_ entity-actor) none 11)
|
|
(process-tree-method-12 () none) ;; 12 ;; (run-logic? (_type_) symbol 12)
|
|
(process-tree-method-13 () none) ;; 13 ;; (process-tree-method-13 () none 13)
|
|
)
|
|
)
|
|
|
|
#|
|
|
(deftype kernel-context (basic)
|
|
((prevent-from-run process-mask :offset-assert 4) ;; guessed by decompiler
|
|
(require-for-run process-mask :offset-assert 8) ;; guessed by decompiler
|
|
(allow-to-run process-mask :offset-assert 12) ;; guessed by decompiler
|
|
(next-pid int32 :offset-assert 16)
|
|
(fast-stack-top pointer :offset-assert 20) ;; guessed by decompiler
|
|
(current-process process :offset-assert 24) ;; guessed by decompiler
|
|
(relocating-process basic :offset-assert 28)
|
|
(relocating-min int32 :offset-assert 32)
|
|
(relocating-max int32 :offset-assert 36)
|
|
(relocating-offset int32 :offset-assert 40)
|
|
(relocating-level level :offset-assert 44) ;; guessed by decompiler
|
|
(low-memory-message symbol :offset-assert 48) ;; guessed by decompiler
|
|
(login-object basic :offset-assert 52)
|
|
(login-art-group basic :offset-assert 56)
|
|
(login-level-index int32 :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
;; field relocating-level uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
;; (deftype time-frame (int64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
(deftype clock (basic)
|
|
((index int16 :offset-assert 4) ;; int32
|
|
(ref-count uint16 :offset-assert 6)
|
|
(mask process-mask :offset-assert 8) ;; guessed by decompiler
|
|
(clock-ratio float :offset-assert 12)
|
|
(accum float :offset-assert 16)
|
|
(integral-accum float :offset-assert 20)
|
|
(frame-counter uint64 :offset-assert 24) ;; time-frame
|
|
(old-frame-counter uint64 :offset-assert 32) ;; time-frame
|
|
(integral-frame-counter uint64 :offset-assert 40)
|
|
(old-integral-frame-counter uint64 :offset-assert 48)
|
|
(sparticle-data vector :inline :offset-assert 64)
|
|
(seconds-per-frame float :offset-assert 80)
|
|
(frames-per-second float :offset-assert 84)
|
|
(time-adjust-ratio float :offset-assert 88)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x5c
|
|
:flag-assert #x180000005c
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(clock-method-9 () none) ;; 9 ;; (update-rates! (_type_ float) float 9)
|
|
(clock-method-10 () none) ;; 10 ;; (advance-by! (_type_ float) clock 10)
|
|
(clock-method-11 () none) ;; 11 ;; (tick! (_type_) clock 11)
|
|
(clock-method-12 () none) ;; 12 ;; (save! (_type_ (pointer uint64)) int 12)
|
|
(clock-method-13 () none) ;; 13 ;; (load! (_type_ (pointer uint64)) int 13)
|
|
(clock-method-14 () none) ;; 14 ;; (reset! (_type_) none 14)
|
|
(clock-method-15 () none) ;; 15
|
|
(clock-method-16 () none) ;; 16
|
|
(clock-method-17 () none) ;; 17
|
|
(clock-method-18 () none) ;; 18
|
|
(clock-method-19 () none) ;; 19
|
|
(clock-method-20 () none) ;; 20
|
|
(clock-method-21 () none) ;; 21
|
|
(clock-method-22 () none) ;; 22
|
|
(clock-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|
|
#|
|
|
(deftype thread (basic)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x28
|
|
:flag-assert #xc00000028
|
|
;; Failed to read fields.
|
|
(:methods
|
|
(thread-method-9 () none) ;; 9 ;; (stack-size-set! (_type_ int) none 9)
|
|
(thread-method-10 () none) ;; 10 ;; (thread-suspend (_type_) none 10)
|
|
(thread-method-11 () none) ;; 11 ;; (thread-resume (_type_) none 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cpu-thread (thread)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x80
|
|
:flag-assert #xc00000080
|
|
;; Failed to read fields.
|
|
(:methods
|
|
;; (new (symbol type process symbol int pointer) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
(deftype dead-pool (process-tree)
|
|
()
|
|
:method-count-assert 16
|
|
:size-assert #x24
|
|
:flag-assert #x1000000024
|
|
(:methods
|
|
;; (new (symbol type int int string) _type_ 0)
|
|
(dead-pool-method-14 () none) ;; 14 ;; (get-process (_type_ type int) process 14)
|
|
(dead-pool-method-15 () none) ;; 15 ;; (return-process (_type_ process) none 15)
|
|
)
|
|
)
|
|
|
|
#|
|
|
(deftype dead-pool-heap-rec (structure)
|
|
((process process :offset-assert 0) ;; guessed by decompiler
|
|
(prev dead-pool-heap-rec :offset-assert 4)
|
|
(next dead-pool-heap-rec :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dead-pool-heap (dead-pool)
|
|
((allocated-length int32 :offset-assert 32)
|
|
(compact-time uint32 :offset-assert 36)
|
|
(compact-count-targ uint32 :offset-assert 40)
|
|
(compact-count uint32 :offset-assert 44)
|
|
(fill-percent float :offset-assert 48)
|
|
(first-gap dead-pool-heap-rec :offset-assert 52)
|
|
(first-shrink dead-pool-heap-rec :offset-assert 56)
|
|
(heap kheap :inline :offset-assert 60)
|
|
(alive-list dead-pool-heap-rec :inline :offset-assert 76)
|
|
(last dead-pool-heap-rec :offset-assert 80)
|
|
(dead-list dead-pool-heap-rec :inline :offset-assert 88)
|
|
(process-list dead-pool-heap-rec :dynamic :offset-assert 100) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #x68
|
|
:flag-assert #x1c00000068
|
|
(:methods
|
|
;; (new (symbol type string int int) _type_ 0)
|
|
(dead-pool-heap-method-16 () none) ;; 16 ;; (init (_type_ symbol int) none 16)
|
|
(dead-pool-heap-method-17 () none) ;; 17 ;; (compact (dead-pool-heap int) none 17)
|
|
(dead-pool-heap-method-18 () none) ;; 18 ;; (shrink-heap (dead-pool-heap process) dead-pool-heap 18)
|
|
(dead-pool-heap-method-19 () none) ;; 19 ;; (churn (dead-pool-heap int) none 19)
|
|
(dead-pool-heap-method-20 () none) ;; 20 ;; (memory-used (_type_) int 20)
|
|
(dead-pool-heap-method-21 () none) ;; 21 ;; (memory-total (_type_) int 21)
|
|
(dead-pool-heap-method-22 () none) ;; 22 ;; (memory-free (dead-pool-heap) int 22)
|
|
(dead-pool-heap-method-23 () none) ;; 23 ;; (compact-time (dead-pool-heap) uint 23)
|
|
(dead-pool-heap-method-24 () none) ;; 24 ;; (gap-size (dead-pool-heap dead-pool-heap-rec) int 24)
|
|
(dead-pool-heap-method-25 () none) ;; 25 ;; (gap-location (dead-pool-heap dead-pool-heap-rec) pointer 25)
|
|
(dead-pool-heap-method-26 () none) ;; 26 ;; (find-gap (dead-pool-heap dead-pool-heap-rec) dead-pool-heap-rec 26)
|
|
(dead-pool-heap-method-27 () none) ;; 27 ;; (find-gap-by-size (dead-pool-heap int) dead-pool-heap-rec 27)
|
|
)
|
|
)
|
|
|#
|
|
|
|
(deftype stack-frame (basic)
|
|
((name symbol :offset 4)
|
|
(next stack-frame :offset 8) ;; which way does this point?
|
|
)
|
|
:size-assert #xc
|
|
:method-count-assert 9
|
|
:flag-assert #x90000000c
|
|
)
|
|
|
|
#|
|
|
(deftype catch-frame (stack-frame)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #xb0
|
|
:flag-assert #x9000000b0
|
|
;; Failed to read fields.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype protect-frame (stack-frame)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
;; Failed to read fields.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype handle (uint64)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype state (protect-frame)
|
|
((name symbol :offset-assert 4) ;; guessed by decompiler
|
|
(next stack-frame :offset-assert 8) ;; guessed by decompiler
|
|
(exit (function object) :offset-assert 12) ;; guessed by decompiler
|
|
(parent basic :offset-assert 16)
|
|
(code function :offset-assert 20) ;; guessed by decompiler
|
|
(trans (function object) :offset-assert 24) ;; guessed by decompiler
|
|
(post function :offset-assert 28) ;; guessed by decompiler
|
|
(enter function :offset-assert 32) ;; guessed by decompiler
|
|
(event (function process int symbol event-message-block object) :offset-assert 36) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype event-message-block (structure)
|
|
((to-handle uint64 :offset-assert 0) ;; handle
|
|
(to (pointer process) :offset-assert 0) ;; guessed by decompiler
|
|
(from-handle uint64 :offset-assert 8)
|
|
(from (pointer process) :offset-assert 8) ;; guessed by decompiler
|
|
(param uint64 6 :offset-assert 16) ;; guessed by decompiler
|
|
(message symbol :offset-assert 64) ;; guessed by decompiler
|
|
(num-params int32 :offset-assert 68)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype event-message-block-array (inline-array-class)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x10
|
|
:flag-assert #xf00000010
|
|
;; Failed to read fields.
|
|
(:methods
|
|
(event-message-block-array-method-14 () none) ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (deftype sql-result (array)
|
|
;; ()
|
|
;; :flag-assert #x900000010
|
|
;; )
|
|
|
|
;; (define-extern *sql-result* object) ;; sql-result
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gkernel ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(deftype process (process-tree)
|
|
((pool dead-pool)
|
|
(status symbol :offset-assert 40) ;; guessed by decompiler
|
|
(pid int32)
|
|
(main-thread cpu-thread :offset-assert 48) ;; guessed by decompiler
|
|
(top-thread cpu-thread :offset-assert 52) ;; guessed by decompiler
|
|
(entity entity-actor :offset-assert 56) ;; guessed by decompiler
|
|
(level level :offset-assert 60) ;; guessed by decompiler
|
|
(state state :offset-assert 64) ;; guessed by decompiler
|
|
(prev-state basic :offset-assert 68)
|
|
(next-state state :offset-assert 72) ;; guessed by decompiler
|
|
(state-stack basic :offset-assert 76)
|
|
(trans-hook function :offset-assert 80) ;; guessed by decompiler
|
|
(post-hook function :offset-assert 84) ;; guessed by decompiler
|
|
(event-hook (function process int symbol event-message-block object) :offset-assert 88) ;; guessed by decompiler
|
|
(allocated-length int32 :offset-assert 92)
|
|
(heap-base pointer :offset-assert 96) ;; guessed by decompiler
|
|
(heap-top pointer :offset-assert 100) ;; guessed by decompiler
|
|
(heap-cur pointer :offset-assert 104) ;; guessed by decompiler
|
|
(stack-frame-top stack-frame :offset-assert 108) ;; guessed by decompiler
|
|
(connection-list connectable :inline :offset-assert 112)
|
|
(stack uint8 :dynamic :offset-assert 128) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x80
|
|
:flag-assert #xe00000080
|
|
(:methods
|
|
;; (new (symbol type string int) _type_ 0)
|
|
)
|
|
(:states
|
|
dead-state ;; 10
|
|
)
|
|
)
|
|
|
|
;; dead-pool-heap is already defined!
|
|
|
|
;; (define-extern *kernel-version* object) ;; binteger
|
|
;; (define-extern *irx-version* object) ;; binteger
|
|
;; (define-extern *kernel-boot-mode* object) ;; symbol
|
|
;; (define-extern *kernel-boot-level* object) ;; symbol
|
|
;; (define-extern *deci-count* object) ;; int
|
|
;; (define-extern *last-loado-length* object) ;; int
|
|
;; (define-extern *last-loado-global-usage* object) ;; int
|
|
;; (define-extern *last-loado-debug-usage* object) ;; int
|
|
;; (define-extern *kernel-packages* object) ;; pair
|
|
;; (define-extern load-package function) ;; (function string kheap pair)
|
|
;; (define-extern unload-package function) ;; (function string pair)
|
|
;; (define-extern *kernel-context* kernel-context) ;; kernel-context
|
|
;; (define-extern *dram-stack* object) ;; (pointer uint8)
|
|
;; (define-extern *null-kernel-context* kernel-context) ;; kernel-context
|
|
;; (define-extern remove-exit function) ;; (function none :behavior process)
|
|
;; (define-extern stream<-process-mask function) ;; (function object process-mask process-mask)
|
|
;; (define-extern *master-mode* object) ;; symbol
|
|
;; (define-extern *pause-lock* object) ;; symbol
|
|
;; (define-extern inspect-process-heap function) ;; (function process symbol)
|
|
;; (define-extern return-from-thread function) ;; (function none)
|
|
;; (define-extern return-from-thread-dead function) ;; (function none)
|
|
;; (define-extern reset-and-call function) ;; (function thread function object)
|
|
;; (define-extern method-state function) ;; (function type basic state)
|
|
;; (define-extern *global-search-name* object) ;; basic
|
|
;; (define-extern *global-search-count* object) ;; int
|
|
;; (define-extern process-by-name function) ;; (function string process-tree process)
|
|
;; (define-extern process-not-name function) ;; (function string process-tree process)
|
|
;; (define-extern process-count function) ;; (function process-tree int)
|
|
;; (define-extern kill-by-name function) ;; (function string process-tree symbol)
|
|
;; (define-extern kill-by-type function) ;; (function type process-tree symbol)
|
|
;; (define-extern kill-not-name function) ;; (function string process-tree symbol)
|
|
;; (define-extern kill-not-type function) ;; (function type process-tree symbol)
|
|
;; (define-extern kill-by-type-inherited function)
|
|
;; (define-extern iterate-process-tree function) ;; (function process-tree (function object object) kernel-context object)
|
|
;; (define-extern execute-process-tree function) ;; (function process-tree (function object object) kernel-context object)
|
|
;; (define-extern search-process-tree function) ;; (function process-tree (function process-tree object) process)
|
|
;; (define-extern kernel-dispatcher function) ;; (function object)
|
|
;; (define-extern sync-dispatcher function) ;; (function object)
|
|
;; (define-extern inspect-process-tree function) ;; (function process-tree int int symbol process-tree)
|
|
;; (define-extern throw-dispatch function) ;; (function catch-frame object none)
|
|
;; (define-extern throw function) ;; (function symbol object int)
|
|
;; (define-extern previous-brother function) ;; (function process-tree object)
|
|
;; (define-extern change-parent function) ;; (function process-tree process-tree process-tree)
|
|
;; (define-extern change-brother function) ;; (function process-tree process-tree object)
|
|
;; (define-extern change-to-last-brother function) ;; (function process-tree process-tree)
|
|
;; (define-extern run-function-in-process function) ;; (function process function object object object object object object object)
|
|
;; (define-extern set-to-run-bootstrap function) ;; (function none)
|
|
;; (define-extern set-to-run function) ;; (function cpu-thread function object object object object object object pointer)
|
|
;; (define-extern entity-deactivate-handler object) ;; (function process entity-actor none)
|
|
;; (define-extern *kernel-clock* clock) ;; clock
|
|
;; (define-extern *vis-boot* object) ;; symbol
|
|
;; (define-extern *null-process* object) ;; process
|
|
;; (define-extern *listener-process* object) ;; process
|
|
;; (define-extern *16k-dead-pool* object) ;; dead-pool
|
|
;; (define-extern *8k-dead-pool* object) ;; dead-pool
|
|
;; (define-extern *4k-dead-pool* object) ;; dead-pool
|
|
;; (define-extern *target-dead-pool* object) ;; dead-pool
|
|
;; (define-extern *camera-dead-pool* object) ;; dead-pool
|
|
;; (define-extern *camera-master-dead-pool* object) ;; dead-pool
|
|
;; (define-extern *debug-dead-pool* object) ;; dead-pool-heap
|
|
;; (define-extern *nk-dead-pool* object) ;; dead-pool-heap
|
|
;; (define-extern *default-dead-pool* object) ;; dead-pool
|
|
;; (define-extern *pickup-dead-pool* object) ;; dead-pool
|
|
;; (define-extern *dead-pool-list* object) ;; pair
|
|
;; (define-extern *active-pool* object) ;; process-tree
|
|
;; (define-extern *display-pool* object) ;; process-tree
|
|
;; (define-extern *camera-pool* object) ;; process-tree
|
|
;; (define-extern *target-pool* object) ;; process-tree
|
|
;; (define-extern *entity-pool* object) ;; process-tree
|
|
;; (define-extern *mid-pool* object) ;; process-tree
|
|
;; (define-extern *pusher-pool* object) ;; process-tree
|
|
;; (define-extern *bg-pool* object) ;; process-tree
|
|
;; (define-extern *default-pool* object) ;; process-tree
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dma-bucket ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern dma-buffer-add-buckets function) ;; (function dma-buffer int (inline-array dma-bucket))
|
|
;; (define-extern dma-buffer-patch-buckets function) ;; (function (inline-array dma-bucket) int (inline-array dma-bucket))
|
|
;; (define-extern dma-bucket-insert-tag function) ;; (function (inline-array dma-bucket) bucket-id pointer (pointer dma-tag) pointer)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cloth-art-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cloth-pt (structure)
|
|
((pt vector :inline :offset-assert 0)
|
|
(u float :offset-assert 16)
|
|
(v float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype anchor-transform (structure)
|
|
((offset vector :inline :offset-assert 0)
|
|
(joint-name basic :offset-assert 16)
|
|
(joint int16 :offset-assert 20)
|
|
(constraint-index int16 :offset-assert 22)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sphere-transform (structure)
|
|
((offset vector :inline :offset-assert 0)
|
|
(joint-name basic :offset-assert 16)
|
|
(radius float :offset-assert 20)
|
|
(joint int16 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1a
|
|
:flag-assert #x90000001a
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype disc-transform (structure)
|
|
((offset vector :inline :offset-assert 0)
|
|
(normal vector :inline :offset-assert 16)
|
|
(joint-name basic :offset-assert 32)
|
|
(radius float :offset-assert 36)
|
|
(joint int16 :offset-assert 40)
|
|
(start-particle-index int16 :offset-assert 42)
|
|
(end-particle-index int16 :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2e
|
|
:flag-assert #x90000002e
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype anchor-transform-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sphere-transform-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype disc-transform-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cloth-thickness-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cloth-params (structure)
|
|
((mesh int16 :offset-assert 0)
|
|
(gravity-constant float :offset-assert 4)
|
|
(wind-constant float :offset-assert 8)
|
|
(cloth-width uint16 :offset-assert 12)
|
|
(num-sphere-constraints uint16 :offset-assert 14)
|
|
(num-disc-constraints uint16 :offset-assert 16)
|
|
(num-anchor-points uint16 :offset-assert 18)
|
|
(flags uint64 :offset-assert 24)
|
|
(tex-name basic :offset-assert 32)
|
|
(tex-name2 basic :offset-assert 36)
|
|
(tex-name3 basic :offset-assert 40)
|
|
(alt-tex-name basic :offset-assert 44)
|
|
(alt-tex-name2 basic :offset-assert 48)
|
|
(alt-tex-name3 basic :offset-assert 52)
|
|
(cloth-thickness float :offset-assert 56)
|
|
(initial-xform int16 :offset-assert 60)
|
|
(drag float :offset-assert 64)
|
|
(ball-collision-radius float :offset-assert 68)
|
|
(num-iterations int8 :offset-assert 72)
|
|
(timestep-frequency int8 :offset-assert 73)
|
|
(secret-disable uint64 :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x58
|
|
:flag-assert #x900000058
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cloth-base (basic)
|
|
()
|
|
:method-count-assert 11
|
|
:size-assert #x4
|
|
:flag-assert #xb00000004
|
|
(:methods
|
|
(cloth-base-method-9 () none) ;; 9
|
|
(cloth-base-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; script ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern command-get-int function) ;; (function object int int)
|
|
;; (define-extern command-get-float function) ;; (function object float float)
|
|
;; (define-extern command-get-time function) ;; (function object int time-frame)
|
|
;; (define-extern command-get-param function) ;; (function object object object)
|
|
;; (define-extern command-get-quoted-param function) ;; (function object object object)
|
|
;; (define-extern command-get-process function) ;; (function object process process)
|
|
;; (define-extern command-get-entity function) ;; (function object entity entity)
|
|
;; (define-extern command-get-trans function) ;; (function object vector vector)
|
|
;; (define-extern key-assoc function) ;; (function object pair vector4w pair)
|
|
;; (define-extern *script-form* object) ;; (inline-array script-form)
|
|
;; (define-extern level-from-heap function) ;; (function int level)
|
|
;; (define-extern *syntax-context* object) ;; script-context
|
|
;; (define-extern *script-context* object) ;; script-context
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype drawable (basic)
|
|
((id int16 :offset-assert 4)
|
|
(bsphere vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
(:methods
|
|
(drawable-method-9 () none) ;; 9 ;; (login (_type_) _type_ 9)
|
|
(drawable-method-10 () none) ;; 10 ;; (draw (_type_ _type_ display-frame) none 10)
|
|
(drawable-method-11 () none) ;; 11 ;; (fill-collide-list-from-box (_type_ int collide-list collide-query) int 11)
|
|
(drawable-method-12 () none) ;; 12 ;; (fill-collide-list-from-line-sphere (_type_ int collide-list collide-query) int 12)
|
|
(drawable-method-13 () none) ;; 13 ;; (collect-stats (_type_) none 13)
|
|
(drawable-method-14 () none) ;; 14 ;; (debug-draw (_type_ drawable display-frame) none 14)
|
|
(drawable-method-15 () none) ;; 15 ;; (unpack-vis (_type_ (pointer int8) (pointer int8)) (pointer int8) 15)
|
|
(drawable-method-16 () none) ;; 16 ;; (collect-regions (_type_ sphere int region-prim-list) none 16)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype drawable-error (drawable)
|
|
((name string :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x24
|
|
:flag-assert #x1100000024
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-vu1-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pris-mtx (structure)
|
|
((data float 32 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 8 :offset-assert 0) ;; guessed by decompiler
|
|
(t-mtx matrix :inline :offset-assert 0)
|
|
(n-mtx matrix3 :inline :offset-assert 64)
|
|
(scale vector :inline :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-pris-mtx-save (structure)
|
|
((loc-mtx pris-mtx :inline :offset-assert 0)
|
|
(par-mtx pris-mtx :inline :offset-assert 128)
|
|
(dif-mtx pris-mtx :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x180
|
|
:flag-assert #x900000180
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-constants (structure)
|
|
((fog vector :inline :offset-assert 0)
|
|
(adgif qword :inline :offset-assert 16) ;; gs-gif-tag :inline
|
|
(hvdf-offset vector :inline :offset-assert 32)
|
|
(hmge-scale vector :inline :offset-assert 48)
|
|
(invh-scale vector :inline :offset-assert 64)
|
|
(guard vector :inline :offset-assert 80)
|
|
(flush qword :inline :offset-assert 96)
|
|
(stores qword :inline :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-shrub-constants (structure)
|
|
((shrub-giftag generic-gif-tag :inline :offset-assert 0)
|
|
(shrub-adnop qword :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gcf-shader (structure)
|
|
((adgif uint128 5 :offset-assert 0) ;; guessed by decompiler
|
|
(shader adgif-shader :inline :offset-assert 0)
|
|
(pos uint32 :offset-assert 12)
|
|
(num uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gcf-control (structure)
|
|
((matrix matrix :inline :offset-assert 0)
|
|
(giftag generic-gif-tag :inline :offset-assert 64)
|
|
(adnops gs-adcmd 2 :offset-assert 80) ;; guessed by decompiler
|
|
(num-strips uint32 :offset-assert 76)
|
|
(num-dps uint32 :offset-assert 92)
|
|
(kick-offset uint32 :offset-assert 108)
|
|
(shader gcf-shader :dynamic :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gcf-vertex (structure)
|
|
((tex vector4w :inline :offset-assert 0)
|
|
(clr gs-packed-rgba :inline :offset-assert 16)
|
|
(pos gs-packed-xyzw :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precurd-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype precurd-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *beam-appearance-1* object)
|
|
;; (define-extern *beam-appearance-2* object)
|
|
;; (define-extern *beam-appearance-3* object)
|
|
;; (define-extern *beam-appearance-4* object)
|
|
;; (define-extern *beam-appearance-5* object)
|
|
;; (define-extern *beam-appearance-6* object)
|
|
;; (define-extern init-mood-precurd function)
|
|
;; (define-extern update-mood-precurd function)
|
|
;; (define-extern precurd-lightjak-do-effect function)
|
|
;; (define-extern precurd-lightjak-stop-effect function)
|
|
;; (define-extern *range-precursor-explo-color* curve-color-fast)
|
|
;; (define-extern *range-precursor-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-precursor-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-precursor-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-precursor-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-precursor-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-precursor-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-precursor-ship-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gstring-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; joint-mod ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern joint-mod-ik-callback function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern real-joint-mod-gun-look-at-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-gun-look-at-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-foot-rot-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern last-try-to-look-at-data object) ;; try-to-look-at-info
|
|
;; (define-extern joint-mod-look-at-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-world-look-at-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-rotate-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-scale-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-joint-set-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-joint-set-world-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-joint-set*-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-joint-set*-world-handler function) ;; (function cspace transformq none :behavior process)
|
|
;; (define-extern joint-mod-polar-look-at-callback function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pskernel ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype lowmemmap (structure)
|
|
((irq-info-stack uint32 :offset-assert 0)
|
|
(irq2-info-stack uint32 :offset-assert 4)
|
|
(kernel-copy-fn uint32 :offset-assert 8)
|
|
(kernel-write-fn uint32 :offset-assert 12)
|
|
(r1-save uint128 :offset-assert 16)
|
|
(last-time uint32 :offset-assert 32)
|
|
(high-time uint32 :offset-assert 36)
|
|
(dma-status uint32 :offset-assert 40)
|
|
(dma-qnext uint32 :offset-assert 44)
|
|
(dma-qwc uint32 :offset-assert 48)
|
|
(dma-tnext uint32 :offset-assert 52)
|
|
(dma-stack0 uint32 :offset-assert 56)
|
|
(dma-stack1 uint32 :offset-assert 60)
|
|
(kernel-read-fn uint32 :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
;; (define-extern kernel-copy-function function) ;; (function object (pointer int32) int32 int32 none)
|
|
;; (define-extern kernel-copy-to-kernel-ram function) ;; (function none)
|
|
;; (define-extern kernel-write-function function) ;; (function object object object none)
|
|
;; (define-extern kernel-write function) ;; (function none)
|
|
;; (define-extern kernel-read-function function) ;; (function object (pointer int32) none)
|
|
;; (define-extern kernel-read function) ;; (function none)
|
|
;; (define-extern kernel-check-hardwired-addresses function) ;; (function none)
|
|
;; (define-extern install-default-debug-handler function) ;; (function object none)
|
|
;; (define-extern return-from-exception function) ;; (function object none)
|
|
;; (define-extern kernel-set-exception-vector function) ;; (function object none)
|
|
;; (define-extern kernel-set-interrupt-vector function) ;; (function none)
|
|
;; (define-extern kernel-set-level2-vector function) ;; (function object object none)
|
|
;; (define-extern deinstall-debug-handler function) ;; (function none)
|
|
;; (define-extern deinstall-debug-handlers function) ;; (function none)
|
|
;; (define-extern resend-exception function) ;; (function object object object object none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; level-info ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *task-level* array) ;; (array symbol)
|
|
;; (define-extern default-level level-load-info) ;; level-load-info
|
|
;; (define-extern intro level-load-info) ;; level-load-info
|
|
;; (define-extern title level-load-info) ;; level-load-info
|
|
;; (define-extern vinroom level-load-info) ;; level-load-info
|
|
;; (define-extern ljkdxvin level-load-info)
|
|
;; (define-extern lvincst level-load-info)
|
|
;; (define-extern powergd level-load-info)
|
|
;; (define-extern ctywide level-load-info) ;; level-load-info
|
|
;; (define-extern ctywide-ff level-load-info)
|
|
;; (define-extern ctywide-ff-kg level-load-info)
|
|
;; (define-extern ctywide-ff-mh level-load-info)
|
|
;; (define-extern ctywide-kg level-load-info)
|
|
;; (define-extern ctywide-mh level-load-info)
|
|
;; (define-extern ctywide-mh-kg level-load-info)
|
|
;; (define-extern citycast level-load-info)
|
|
;; (define-extern gridcst level-load-info)
|
|
;; (define-extern ctycara level-load-info)
|
|
;; (define-extern ctycarkg level-load-info)
|
|
;; (define-extern ctycarb level-load-info)
|
|
;; (define-extern ctycarc level-load-info)
|
|
;; (define-extern ctypepa level-load-info)
|
|
;; (define-extern lpatkcs level-load-info)
|
|
;; (define-extern lblowtmh level-load-info)
|
|
;; (define-extern lblowtkg level-load-info)
|
|
;; (define-extern ctypepb level-load-info)
|
|
;; (define-extern lblowcst level-load-info)
|
|
;; (define-extern ctypepc level-load-info)
|
|
;; (define-extern ctypesa level-load-info)
|
|
;; (define-extern ctypesb level-load-info)
|
|
;; (define-extern ctypesc level-load-info)
|
|
;; (define-extern intpfall level-load-info)
|
|
;; (define-extern ctygenb level-load-info) ;; level-load-info
|
|
;; (define-extern ctysluma level-load-info) ;; level-load-info
|
|
;; (define-extern ctyslumb level-load-info) ;; level-load-info
|
|
;; (define-extern slumbset level-load-info)
|
|
;; (define-extern ctyslumc level-load-info) ;; level-load-info
|
|
;; (define-extern ctyport level-load-info) ;; level-load-info
|
|
;; (define-extern ctyfarma level-load-info) ;; level-load-info
|
|
;; (define-extern ctyfarmb level-load-info) ;; level-load-info
|
|
;; (define-extern ctyinda level-load-info) ;; level-load-info
|
|
;; (define-extern ctyindb level-load-info) ;; level-load-info
|
|
;; (define-extern stadium level-load-info) ;; level-load-info
|
|
;; (define-extern stadiuma level-load-info)
|
|
;; (define-extern lppatrol level-load-info)
|
|
;; (define-extern lpattack level-load-info)
|
|
;; (define-extern stadiumb level-load-info) ;; level-load-info
|
|
;; (define-extern towera level-load-info)
|
|
;; (define-extern towerb level-load-info)
|
|
;; (define-extern towerc level-load-info)
|
|
;; (define-extern towercst level-load-info)
|
|
;; (define-extern ltowera level-load-info)
|
|
;; (define-extern ltowcity level-load-info)
|
|
;; (define-extern ltowerb level-load-info)
|
|
;; (define-extern rubblea level-load-info)
|
|
;; (define-extern rubblea2 level-load-info)
|
|
;; (define-extern rubbleb level-load-info)
|
|
;; (define-extern rubblec level-load-info)
|
|
;; (define-extern rublcst level-load-info)
|
|
;; (define-extern lbombbot level-load-info) ;; level-load-info
|
|
;; (define-extern ljinx level-load-info)
|
|
;; (define-extern lctypatk level-load-info)
|
|
;; (define-extern lctyhijk level-load-info)
|
|
;; (define-extern lctypalt level-load-info)
|
|
;; (define-extern lctyass level-load-info)
|
|
;; (define-extern lctydest level-load-info)
|
|
;; (define-extern lctyprot level-load-info)
|
|
;; (define-extern lctyblow level-load-info)
|
|
;; (define-extern lctysnpr level-load-info)
|
|
;; (define-extern onintent level-load-info) ;; level-load-info
|
|
;; (define-extern lbbush level-load-info) ;; level-load-info
|
|
;; (define-extern hiphog level-load-info) ;; level-load-info
|
|
;; (define-extern ltnjxhip level-load-info)
|
|
;; (define-extern gungame level-load-info) ;; level-load-info
|
|
;; (define-extern gungame1 level-load-info)
|
|
;; (define-extern gungame2 level-load-info)
|
|
;; (define-extern citylow level-load-info)
|
|
;; (define-extern freehq level-load-info)
|
|
;; (define-extern freecast level-load-info)
|
|
;; (define-extern lfreeout level-load-info)
|
|
;; (define-extern mhctycst level-load-info)
|
|
;; (define-extern mhcitya level-load-info)
|
|
;; (define-extern mhcityb level-load-info)
|
|
;; (define-extern lmhcitya level-load-info)
|
|
;; (define-extern lmhcityb level-load-info)
|
|
;; (define-extern comba level-load-info)
|
|
;; (define-extern combb level-load-info)
|
|
;; (define-extern combc level-load-info)
|
|
;; (define-extern combd level-load-info)
|
|
;; (define-extern combe level-load-info)
|
|
;; (define-extern combm level-load-info)
|
|
;; (define-extern combn level-load-info)
|
|
;; (define-extern combx level-load-info)
|
|
;; (define-extern raila level-load-info)
|
|
;; (define-extern railb level-load-info)
|
|
;; (define-extern railb2 level-load-info)
|
|
;; (define-extern railc level-load-info)
|
|
;; (define-extern raild level-load-info)
|
|
;; (define-extern raile level-load-info)
|
|
;; (define-extern railf level-load-info)
|
|
;; (define-extern railx level-load-info)
|
|
;; (define-extern lcitysml level-load-info)
|
|
;; (define-extern railcst level-load-info)
|
|
;; (define-extern minea level-load-info)
|
|
;; (define-extern lpeckfly level-load-info)
|
|
;; (define-extern mineb level-load-info)
|
|
;; (define-extern minec level-load-info)
|
|
;; (define-extern mined level-load-info)
|
|
;; (define-extern minee level-load-info)
|
|
;; (define-extern sewa level-load-info)
|
|
;; (define-extern sewb level-load-info)
|
|
;; (define-extern sewc level-load-info)
|
|
;; (define-extern sewd level-load-info)
|
|
;; (define-extern sewe level-load-info)
|
|
;; (define-extern sewf level-load-info)
|
|
;; (define-extern sewg level-load-info)
|
|
;; (define-extern sewh level-load-info)
|
|
;; (define-extern sewi level-load-info)
|
|
;; (define-extern sewj level-load-info)
|
|
;; (define-extern sewk level-load-info)
|
|
;; (define-extern sewl level-load-info)
|
|
;; (define-extern sewm level-load-info)
|
|
;; (define-extern sewn level-load-info)
|
|
;; (define-extern sewo level-load-info)
|
|
;; (define-extern forestx level-load-info)
|
|
;; (define-extern foresta level-load-info)
|
|
;; (define-extern lforplnt level-load-info)
|
|
;; (define-extern lforring level-load-info)
|
|
;; (define-extern lformach level-load-info)
|
|
;; (define-extern forestb level-load-info) ;; level-load-info
|
|
;; (define-extern wasintro level-load-info)
|
|
;; (define-extern introcst level-load-info) ;; level-load-info
|
|
;; (define-extern intpalrf level-load-info)
|
|
;; (define-extern inttitle level-load-info)
|
|
;; (define-extern wasall level-load-info)
|
|
;; (define-extern waswide level-load-info)
|
|
;; (define-extern wascitya level-load-info)
|
|
;; (define-extern lseemwca level-load-info)
|
|
;; (define-extern wascityb level-load-info)
|
|
;; (define-extern wascast level-load-info)
|
|
;; (define-extern wasseem level-load-info)
|
|
;; (define-extern waspgame level-load-info)
|
|
;; (define-extern wasdefen level-load-info)
|
|
;; (define-extern wcaseem level-load-info)
|
|
;; (define-extern wasleapr level-load-info)
|
|
;; (define-extern wasdoors level-load-info)
|
|
;; (define-extern outrocst level-load-info) ;; level-load-info
|
|
;; (define-extern outcast3 level-load-info)
|
|
;; (define-extern loutro level-load-info)
|
|
;; (define-extern loutro2 level-load-info)
|
|
;; (define-extern loutro3 level-load-info)
|
|
;; (define-extern wasstada level-load-info)
|
|
;; (define-extern wasstadb level-load-info)
|
|
;; (define-extern wasstadc level-load-info)
|
|
;; (define-extern arenacst level-load-info)
|
|
;; (define-extern museum level-load-info)
|
|
;; (define-extern museum2 level-load-info)
|
|
;; (define-extern museum3 level-load-info)
|
|
;; (define-extern museum3b level-load-info)
|
|
;; (define-extern museum4 level-load-info)
|
|
;; (define-extern museum4b level-load-info)
|
|
;; (define-extern temp level-load-info)
|
|
;; (define-extern ldampeck level-load-info)
|
|
;; (define-extern ldmpckgn level-load-info)
|
|
;; (define-extern ldamsig level-load-info)
|
|
;; (define-extern ldampksm level-load-info)
|
|
;; (define-extern lkleever level-load-info)
|
|
;; (define-extern lsig level-load-info)
|
|
;; (define-extern lsigklv level-load-info)
|
|
;; (define-extern lsigjakc level-load-info)
|
|
;; (define-extern loninsim level-load-info)
|
|
;; (define-extern ljakc level-load-info)
|
|
;; (define-extern ljakndax level-load-info)
|
|
;; (define-extern lsamos level-load-info)
|
|
;; (define-extern ljakcklv level-load-info)
|
|
;; (define-extern ljkcdmkl level-load-info)
|
|
;; (define-extern ldamklev level-load-info)
|
|
;; (define-extern lashelin level-load-info)
|
|
;; (define-extern ljak level-load-info)
|
|
;; (define-extern ljakklev level-load-info)
|
|
;; (define-extern ljaksig level-load-info)
|
|
;; (define-extern ljkdmpk level-load-info)
|
|
;; (define-extern ljndklev level-load-info)
|
|
;; (define-extern ltorn level-load-info)
|
|
;; (define-extern lerrol level-load-info) ;; level-load-info
|
|
;; (define-extern ltornsam level-load-info)
|
|
;; (define-extern ltornjnx level-load-info)
|
|
;; (define-extern ltnfxhip level-load-info)
|
|
;; (define-extern lwlandm level-load-info)
|
|
;; (define-extern ltrtwhls level-load-info)
|
|
;; (define-extern lsnkwhls level-load-info)
|
|
;; (define-extern lbiped level-load-info)
|
|
;; (define-extern lmech level-load-info)
|
|
;; (define-extern lprenme level-load-info)
|
|
;; (define-extern lgunnorm level-load-info)
|
|
;; (define-extern lgunrnc level-load-info)
|
|
;; (define-extern waschase level-load-info)
|
|
;; (define-extern waspala level-load-info)
|
|
;; (define-extern lwstdpck level-load-info)
|
|
;; (define-extern ljkfeet level-load-info)
|
|
;; (define-extern desert level-load-info)
|
|
;; (define-extern warpcast level-load-info)
|
|
;; (define-extern deserta level-load-info)
|
|
;; (define-extern desbcst level-load-info)
|
|
;; (define-extern deserrol level-load-info)
|
|
;; (define-extern desertb level-load-info)
|
|
;; (define-extern desertc level-load-info)
|
|
;; (define-extern desertd level-load-info)
|
|
;; (define-extern deserte level-load-info)
|
|
;; (define-extern desertf level-load-info)
|
|
;; (define-extern desertg level-load-info)
|
|
;; (define-extern ldesgcst level-load-info)
|
|
;; (define-extern deserth level-load-info)
|
|
;; (define-extern deswalk level-load-info)
|
|
;; (define-extern desert-game level-load-info)
|
|
;; (define-extern desrace1 level-load-info)
|
|
;; (define-extern desboss1 level-load-info)
|
|
;; (define-extern desboss2 level-load-info)
|
|
;; (define-extern desinter level-load-info)
|
|
;; (define-extern destrack level-load-info)
|
|
;; (define-extern desrally level-load-info)
|
|
;; (define-extern deshover level-load-info)
|
|
;; (define-extern deshunt level-load-info)
|
|
;; (define-extern desliz level-load-info)
|
|
;; (define-extern desresc level-load-info)
|
|
;; (define-extern desrescc level-load-info)
|
|
;; (define-extern desrescg level-load-info)
|
|
;; (define-extern desoasis level-load-info)
|
|
;; (define-extern oasiscst level-load-info)
|
|
;; (define-extern desjump level-load-info)
|
|
;; (define-extern deschase level-load-info)
|
|
;; (define-extern desbattl level-load-info)
|
|
;; (define-extern lwassig level-load-info)
|
|
;; (define-extern lwasbbv level-load-info)
|
|
;; (define-extern lnstcst level-load-info)
|
|
;; (define-extern lbbring1 level-load-info)
|
|
;; (define-extern lbbring2 level-load-info)
|
|
;; (define-extern lbbring3 level-load-info)
|
|
;; (define-extern lbbring4 level-load-info)
|
|
;; (define-extern lbbring5 level-load-info)
|
|
;; (define-extern lbbring6 level-load-info)
|
|
;; (define-extern lbbring7 level-load-info)
|
|
;; (define-extern lbbtcha1 level-load-info)
|
|
;; (define-extern lbbtcha2 level-load-info)
|
|
;; (define-extern lbbtcha3 level-load-info)
|
|
;; (define-extern lbbspid level-load-info)
|
|
;; (define-extern lbbspirt level-load-info)
|
|
;; (define-extern lbbsprt2 level-load-info)
|
|
;; (define-extern lbbsprt3 level-load-info)
|
|
;; (define-extern lbbsdrp1 level-load-info)
|
|
;; (define-extern lbbsdrp2 level-load-info)
|
|
;; (define-extern lbbsdrp3 level-load-info)
|
|
;; (define-extern nsta level-load-info)
|
|
;; (define-extern nstb level-load-info)
|
|
;; (define-extern lnstoba level-load-info)
|
|
;; (define-extern lnstobb level-load-info)
|
|
;; (define-extern lnstobc level-load-info)
|
|
;; (define-extern templex level-load-info)
|
|
;; (define-extern templea level-load-info)
|
|
;; (define-extern templeb level-load-info)
|
|
;; (define-extern templec level-load-info)
|
|
;; (define-extern templed level-load-info)
|
|
;; (define-extern templee level-load-info)
|
|
;; (define-extern hanga level-load-info)
|
|
;; (define-extern hangb level-load-info)
|
|
;; (define-extern volcanox level-load-info)
|
|
;; (define-extern volcanoa level-load-info)
|
|
;; (define-extern factorya level-load-info)
|
|
;; (define-extern lfactory level-load-info)
|
|
;; (define-extern lfaccar level-load-info)
|
|
;; (define-extern lfacrm1 level-load-info)
|
|
;; (define-extern lfacrm2 level-load-info)
|
|
;; (define-extern lfaccity level-load-info)
|
|
;; (define-extern lfacctyb level-load-info)
|
|
;; (define-extern factoryb level-load-info)
|
|
;; (define-extern factoryc level-load-info)
|
|
;; (define-extern factoryd level-load-info)
|
|
;; (define-extern lfacout level-load-info)
|
|
;; (define-extern warinta level-load-info)
|
|
;; (define-extern precura level-load-info)
|
|
;; (define-extern precurb level-load-info)
|
|
;; (define-extern precurc level-load-info)
|
|
;; (define-extern lprecurc level-load-info)
|
|
;; (define-extern precurd level-load-info)
|
|
;; (define-extern bikearena level-load-info)
|
|
;; (define-extern halfpipe level-load-info) ;; level-load-info
|
|
;; (define-extern sndtest level-load-info)
|
|
;; (define-extern vistest level-load-info) ;; level-load-info
|
|
;; (define-extern bsbs level-load-info)
|
|
;; (define-extern tobytest level-load-info) ;; level-load-info
|
|
;; (define-extern hermtest level-load-info)
|
|
;; (define-extern chartest level-load-info) ;; level-load-info
|
|
;; (define-extern ctyfence level-load-info) ;; level-load-info
|
|
;; (define-extern testisle level-load-info)
|
|
;; (define-extern gregtest level-load-info)
|
|
;; (define-extern 4amy level-load-info)
|
|
;; (define-extern *level-load-list* object) ;; pair
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-towera ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *towera-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hvehicle-util ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; height-map-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype xz-height-map (structure)
|
|
((offset float 3 :offset-assert 0) ;; guessed by decompiler
|
|
(x-offset float :offset-assert 0)
|
|
(y-offset float :offset-assert 4)
|
|
(z-offset float :offset-assert 8)
|
|
(x-inv-spacing float :offset-assert 12)
|
|
(z-inv-spacing float :offset-assert 16)
|
|
(y-scale float :offset-assert 20)
|
|
(dim int16 2 :offset-assert 24) ;; guessed by decompiler
|
|
(x-dim int16 :offset-assert 24)
|
|
(z-dim int16 :offset-assert 26)
|
|
(data (pointer int8) :offset-assert 28) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x20
|
|
:flag-assert #xf00000020
|
|
(:methods
|
|
(xz-height-map-method-9 () none) ;; 9 ;; (get-height-at-point (_type_ vector) float 9)
|
|
(xz-height-map-method-10 () none) ;; 10 ;; (debug-draw-mesh (_type_ vector) none 10)
|
|
(xz-height-map-method-11 () none) ;; 11 ;; (debug-print (_type_) none 11)
|
|
(xz-height-map-method-12 () none) ;; 12 ;; (debug-draw-at-point (_type_ vector) none 12)
|
|
(xz-height-map-method-13 () none) ;; 13 ;; (debug-draw (_type_ vector) none 13)
|
|
(xz-height-map-method-14 () none) ;; 14 ;; (debug-add-offset (_type_ vector int) none 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern get-traffic-height function) ;; (function vector float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; camera-defs-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype camera-bank (basic)
|
|
((collide-move-rad float :offset-assert 4)
|
|
(joypad uint32 :offset-assert 8)
|
|
(min-detectable-velocity float :offset-assert 12)
|
|
(attack-timeout uint64 :offset-assert 16) ;; time-frame
|
|
(default-string-max-y meters :offset-assert 24)
|
|
(default-string-min-y meters :offset-assert 28)
|
|
(default-string-max-z meters :offset-assert 32)
|
|
(default-string-min-z meters :offset-assert 36)
|
|
(default-string-push-z meters :offset-assert 40)
|
|
(default-tilt-adjust deg :offset-assert 44) ;; degrees
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype camera-master-bank (basic)
|
|
((onscreen-head-height meters :offset-assert 4)
|
|
(onscreen-foot-height meters :offset-assert 8)
|
|
(target-height meters :offset-assert 12)
|
|
(up-move-to-pitch-ratio-in-air float :offset-assert 16)
|
|
(down-move-to-pitch-ratio-in-air float :offset-assert 20)
|
|
(up-move-to-pitch-on-ground float :offset-assert 24)
|
|
(down-move-to-pitch-on-ground float :offset-assert 28)
|
|
(pitch-off-blend float :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *CAMERA-bank* camera-bank) ;; camera-bank
|
|
;; (define-extern *CAMERA_MASTER-bank* camera-master-bank) ;; camera-master-bank
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; turtle-training ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype des-train-bollard (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-train-barrier (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-train-stones (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype turtle-training-goal (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-turtle-training (task-manager)
|
|
((goal-array UNKNOWN 7 :offset-assert 240)
|
|
(door-plane vector :inline :offset-assert 352)
|
|
(start-pos vector :inline :offset-assert 368)
|
|
(goal-pos vector :inline :offset-assert 384)
|
|
(player-pos vector :inline :offset-assert 400)
|
|
(player-vel vector :inline :offset-assert 416)
|
|
(player-controls vehicle-controls :inline :offset-assert 432)
|
|
(test-time uint64 :offset-assert 456)
|
|
(max-count int16 :offset-assert 464)
|
|
(show-message? basic :offset-assert 468)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x1d8
|
|
:flag-assert #x21016001d8
|
|
(:methods
|
|
(task-manager-desert-turtle-training-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vu1-user-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dma-foreground-sink (basic)
|
|
((bucket int32 :offset-assert 4) ;; bucket-id
|
|
(foreground-texture-page int8 :offset-assert 8) ;; tpage-category
|
|
(foreground-texture-level int8 :offset-assert 9)
|
|
(foreground-output-bucket int8 :offset-assert 10)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xb
|
|
:flag-assert #x90000000b
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-bucket-state (structure)
|
|
((gifbuf-adr uint32 :offset-assert 0)
|
|
(inbuf-adr uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-dma-foreground-sink (dma-foreground-sink)
|
|
((state generic-bucket-state :inline :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; enemy-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern gun-dark-2-anim-code function)
|
|
;; (define-extern gun-dark-2-ragdoll-start function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyslumb-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern check-drop-level-ctyslumb-drop-userdata function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern *ctyslumb-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dgo-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dgo-header (structure)
|
|
((length uint32 :offset-assert 0)
|
|
(rootname uint8 60 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dgo-entry (structure)
|
|
((offset uint32 :offset-assert 0)
|
|
(length uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dgo-file (basic)
|
|
((num-go-files uint32 :offset-assert 4)
|
|
(total-length uint32 :offset-assert 8)
|
|
(rsvd uint32 :offset-assert 12)
|
|
(data uint8 :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bounding-box-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bounding-box (structure)
|
|
((min vector :inline :offset-assert 0)
|
|
(max vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x20
|
|
:flag-assert #x1500000020
|
|
(:methods
|
|
(bounding-box-method-9 () none) ;; 9 ;; (add-spheres! (_type_ (inline-array sphere) int) int 9)
|
|
(bounding-box-method-10 () none) ;; 10 ;; (add-box! (_type_ bounding-box) int 10)
|
|
(bounding-box-method-11 () none) ;; 11 ;; (add-point! (_type_ vector) none 11)
|
|
(bounding-box-method-12 () none) ;; 12 ;; (intersects-line-segment? (_type_ vector vector) symbol 12)
|
|
(bounding-box-method-13 () none) ;; 13 ;; (set-from-point-offset! (_type_ vector vector) none 13)
|
|
(bounding-box-method-14 () none) ;; 14 ;; (set-from-point-offset-pad! (_type_ vector vector float) int 14)
|
|
(bounding-box-method-15 () none) ;; 15 ;; (set-to-point! (_type_ vector) none 15)
|
|
(bounding-box-method-16 () none) ;; 16 ;; (set-from-sphere! (_type_ sphere) none 16)
|
|
(bounding-box-method-17 () none) ;; 17 ;; (set-from-spheres! (_type_ (inline-array sphere) int) int 17)
|
|
(bounding-box-method-18 () none) ;; 18 ;; (get-bounding-sphere (_type_ vector) vector 18)
|
|
(bounding-box-method-19 () none) ;; 19 ;; (inside-xyz? (bounding-box vector) symbol 19)
|
|
(bounding-box-method-20 () none) ;; 20 ;; (inside-xz? (bounding-box vector) symbol 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bounding-box2 (structure)
|
|
((min vector2 :inline :offset-assert 0)
|
|
(max vector2 :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bounding-box4w (structure)
|
|
((min vector4w :inline :offset-assert 0)
|
|
(max vector4w :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bounding-box-both (structure)
|
|
((box bounding-box :inline :offset-assert 0)
|
|
(box4w bounding-box4w :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bounding-box-array (inline-array-class)
|
|
((data bounding-box :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; game-save ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype game-save-tag (structure)
|
|
((user-object object 2 :offset-assert 0) ;; guessed by decompiler
|
|
(user-uint64 uint64 :offset-assert 0)
|
|
(user-float0 float :offset-assert 0)
|
|
(user-float float 2 :offset-assert 0) ;; guessed by decompiler
|
|
(user-int32 int32 2 :offset-assert 0) ;; guessed by decompiler
|
|
(user-uint32 uint32 2 :offset-assert 0) ;; guessed by decompiler
|
|
(user-int16 int16 4 :offset-assert 0) ;; guessed by decompiler
|
|
(user-uint16 uint16 4 :offset-assert 0) ;; guessed by decompiler
|
|
(user-int8 int8 8 :offset-assert 0) ;; guessed by decompiler
|
|
(user-int80 int8 :offset-assert 0)
|
|
(user-int81 int8 :offset-assert 1)
|
|
(user-uint8 uint8 8 :offset-assert 0) ;; guessed by decompiler
|
|
(elt-count int32 :offset-assert 8)
|
|
(elt-size uint16 :offset-assert 12)
|
|
(elt-type uint16 :offset-assert 14) ;; game-save-elt
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype game-save (basic)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x50
|
|
:flag-assert #xc00000050
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(game-save-method-9 () none) ;; 9 ;; (save-to-file (_type_ string) _type_ 9)
|
|
(game-save-method-10 () none) ;; 10 ;; (load-from-file (_type_ string) _type_ 10)
|
|
(game-save-method-11 () none) ;; 11 ;; (debug-inspect (_type_ symbol) _type_ 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype auto-save (process)
|
|
((card int32 :offset-assert 128)
|
|
(slot int32 :offset-assert 132)
|
|
(which int32 :offset-assert 136)
|
|
(buffer kheap :offset-assert 140)
|
|
(mode symbol :offset-assert 144) ;; guessed by decompiler
|
|
(starting-auto-save-status basic :offset-assert 148)
|
|
(result mc-status-code :offset-assert 152) ;; guessed by decompiler
|
|
(save game-save :offset-assert 156) ;; guessed by decompiler
|
|
(info mc-slot-info :inline :offset-assert 160)
|
|
(notify uint64 :offset-assert 464) ;; handle
|
|
(force symbol :offset-assert 472) ;; guessed by decompiler
|
|
(state-time uint64 :offset-assert 480) ;; time-frame
|
|
(icon hud-sprite :inline :offset-assert 496)
|
|
(icon-gui-id uint32 :offset-assert 548)
|
|
(message-gui-id uint32 :offset-assert 552)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x22c
|
|
:flag-assert #x1701b0022c
|
|
(:state-methods
|
|
get-heap ;; 14, old: (get-heap () _type_ :state 14)
|
|
get-card ;; 15, old: (get-card () _type_ :state 15)
|
|
format-card ;; 16, old: (format-card () _type_ :state 16)
|
|
unformat-card ;; 17, old: (unformat-card () _type_ :state 17)
|
|
create-file ;; 18, old: (create-file () _type_ :state 18)
|
|
save ;; 19, old: (save () _type_ :state 19)
|
|
restore ;; 20, old: (restore () _type_ :state 20)
|
|
error ;; 21, old: (error (mc-status-code) _type_ :state 21)
|
|
done ;; 22, old: (done () _type_ :state 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern game-save-elt->string function) ;; (function game-save-elt string)
|
|
;; (define-extern *auto-save-info* object) ;; mc-slot-info
|
|
;; (define-extern auto-save-post function) ;; (function pointer :behavior auto-save)
|
|
;; (define-extern auto-save-init-by-other function) ;; (function symbol process int int symbol object :behavior auto-save)
|
|
;; (define-extern auto-save-command function) ;; (function symbol int int process-tree symbol (pointer auto-save))
|
|
;; (define-extern auto-save-check function) ;; (function int)
|
|
;; (define-extern auto-save-user function) ;; (function (pointer auto-save))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; transform ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern transform-matrix-calc! function) ;; (function transform matrix matrix)
|
|
;; (define-extern transform-matrix-parent-calc! function) ;; (function transform matrix vector matrix)
|
|
;; (define-extern trs-matrix-calc! function) ;; (function trs matrix matrix)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precurc-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype precurc-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern init-mood-precurc function)
|
|
;; (define-extern update-precurc-lights function)
|
|
;; (define-extern update-mood-precurc function)
|
|
;; (define-extern precurc-activate function)
|
|
;; (define-extern precur-deactivate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bot-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gstate ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern inherit-state function) ;; (function state state state)
|
|
;; (define-extern state-type? function)
|
|
;; (define-extern enter-state function) ;; (function object object object object object object object)
|
|
;; (define-extern *event-queue* object) ;; event-message-block-array
|
|
;; (define-extern send-event-function function) ;; (function process-tree event-message-block object)
|
|
;; (define-extern looping-code function) ;; (function symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; weather-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern group-rain-screend-drop object) ;; sparticle-launch-group
|
|
;; (define-extern update-snow function) ;; (function float vector vector none)
|
|
;; (define-extern birth-func-omega-normal-orient function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern birth-func-rain function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern check-drop-level-rain function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern check-drop-level-rain2 function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern check-drop-level-splash function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern update-rain function) ;; (function float vector vector none)
|
|
;; (define-extern cam-master-effect function) ;; (function none :behavior camera-master)
|
|
;; (define-extern sparticle-track-sun function) ;; (function int sparticle-cpuinfo matrix none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctymark-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern check-market-piece-ground function) ;; (function sparticle-system sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern market-activate function) ;; (function level none)
|
|
;; (define-extern *fruit-check-ground-counter* object) ;; int
|
|
;; (define-extern fruit-check-ground-bounce function) ;; (function sparticle-system sparticle-cpuinfo sparticle-launchinfo matrix float)
|
|
;; (define-extern fruit-sparticle-next-on-mode-1 function) ;; (function sparticle-system sparticle-cpuinfo sparticle-launchinfo float)
|
|
;; (define-extern fruit-stand-event-handler function) ;; (function process int symbol event-message-block object :behavior fruit-stand)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; etie-vu1 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype etie-consts (structure)
|
|
((gifbufs qword :inline :offset-assert 0)
|
|
(adgif qword :inline :offset-assert 16) ;; gs-gif-tag :inline
|
|
(alpha qword :inline :offset-assert 32)
|
|
(strgif qword :inline :offset-assert 48) ;; gs-gif-tag :inline
|
|
(envgif qword :inline :offset-assert 64) ;; gs-gif-tag :inline
|
|
(envmap adgif-shader :inline :offset-assert 80)
|
|
(pers0 vector :inline :offset-assert 160)
|
|
(pers1 vector :inline :offset-assert 176)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc0
|
|
:flag-assert #x9000000c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype etie-matrix (structure)
|
|
((rmtx matrix :inline :offset-assert 0)
|
|
(nmtx matrix3 :inline :offset-assert 64)
|
|
(morph float :offset-assert 76)
|
|
(fog float :offset-assert 92)
|
|
(fade uint32 :offset-assert 108)
|
|
(tint qword :inline :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
;; (define-extern etie-vu1-block object) ;; vu-function
|
|
;; (define-extern etie-magic function) ;; (function int int)
|
|
;; (define-extern etie-init-consts function) ;; (function etie-consts gs-alpha none)
|
|
;; (define-extern etie-init-engine function) ;; (function dma-buffer gs-alpha gs-test none)
|
|
;; (define-extern etie-end-buffer function) ;; (function dma-buffer none)
|
|
;; (define-extern etie-float-reg-bp function)
|
|
;; (define-extern etie-float-reg function)
|
|
;; (define-extern etie-floats function)
|
|
;; (define-extern etie-int-reg function)
|
|
;; (define-extern etie-ints function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; types-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype basic-reserved (basic)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x4
|
|
:flag-assert #x1d00000004
|
|
(:methods
|
|
(basic-reserved-method-9 () none) ;; 9
|
|
(basic-reserved-method-10 () none) ;; 10
|
|
(basic-reserved-method-11 () none) ;; 11
|
|
(basic-reserved-method-12 () none) ;; 12
|
|
(basic-reserved-method-13 () none) ;; 13
|
|
(basic-reserved-method-14 () none) ;; 14
|
|
(basic-reserved-method-15 () none) ;; 15
|
|
(basic-reserved-method-16 () none) ;; 16
|
|
(basic-reserved-method-17 () none) ;; 17
|
|
(basic-reserved-method-18 () none) ;; 18
|
|
(basic-reserved-method-19 () none) ;; 19
|
|
(basic-reserved-method-20 () none) ;; 20
|
|
(basic-reserved-method-21 () none) ;; 21
|
|
(basic-reserved-method-22 () none) ;; 22
|
|
(basic-reserved-method-23 () none) ;; 23
|
|
(basic-reserved-method-24 () none) ;; 24
|
|
(basic-reserved-method-25 () none) ;; 25
|
|
(basic-reserved-method-26 () none) ;; 26
|
|
(basic-reserved-method-27 () none) ;; 27
|
|
(basic-reserved-method-28 () none) ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (deftype part-id (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-guard-projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vehicle-grenade (projectile-bounce)
|
|
((blast-radius float :offset-assert 548)
|
|
)
|
|
:method-count-assert 45
|
|
:size-assert #x228
|
|
:flag-assert #x2d01b00228
|
|
(:methods
|
|
(vehicle-grenade-method-44 () none) ;; 44
|
|
)
|
|
(:state-methods
|
|
impact ;; 22
|
|
sitting ;; 41
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-grenade-deflect (vehicle-grenade)
|
|
((has-been-deflected basic :offset-assert 552)
|
|
(has-hit-ground basic :offset-assert 556)
|
|
)
|
|
:method-count-assert 45
|
|
:size-assert #x230
|
|
:flag-assert #x2d01b00230
|
|
(:state-methods
|
|
moving ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype guard-lazer-shot (projectile)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x200
|
|
:flag-assert #x2901800200
|
|
(:state-methods
|
|
dissipate ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern guard-lazer-shot-move function) ;; (function guard-lazer-shot none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype check-vector-collision-with-nav-spheres-info (structure)
|
|
((u float :offset-assert 0)
|
|
(intersect vector :inline :offset-assert 16)
|
|
(normal vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-gap-info (structure)
|
|
((dest vector :inline :offset-assert 0)
|
|
(poly nav-poly :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-avoid-spheres-params (structure)
|
|
((current-pos vector :inline :offset-assert 0)
|
|
(travel vector :inline :offset-assert 16)
|
|
(pref-dir vector :inline :offset-assert 32)
|
|
(out-travel vector 2 :offset-assert 48) ;; guessed by decompiler
|
|
(closest-sphere-dist2 float :offset-assert 80)
|
|
(avoiding-sphere? symbol :offset-assert 84) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x58
|
|
:flag-assert #x900000058
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-callback-info (structure)
|
|
((callback-count int32 :offset-assert 0)
|
|
(callback-array (function object nav-control none) 10 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-state (structure)
|
|
((flags nav-state-flag :offset-assert 0)
|
|
(nav nav-control :offset-assert 4) ;; guessed by decompiler
|
|
(user-poly nav-poly :offset-assert 8)
|
|
(mesh nav-mesh :offset-assert 12) ;; guessed by decompiler
|
|
(current-poly nav-poly :offset-assert 16)
|
|
(virtual-current-poly nav-poly :offset-assert 20)
|
|
(next-poly nav-poly :offset-assert 24)
|
|
(target-poly nav-poly :offset-assert 28)
|
|
(rotation-rate float :offset-assert 32)
|
|
(speed meters :offset-assert 36)
|
|
(prev-speed meters :offset-assert 40)
|
|
(pad0 uint32 1 :offset-assert 44) ;; guessed by decompiler
|
|
(travel vector :inline :offset-assert 48)
|
|
(target-pos vector :inline :offset-assert 64)
|
|
(current-pos vector :inline :offset-assert 80)
|
|
(current-pos-local vector :inline :offset-assert 96)
|
|
(virtual-current-pos-local vector :inline :offset-assert 112)
|
|
(velocity vector :inline :offset-assert 128)
|
|
(heading vector :inline :offset-assert 144)
|
|
(target-dir vector :inline :offset-assert 160)
|
|
(accel vector :inline :offset-assert 160)
|
|
(user-position vector :inline :offset-assert 112)
|
|
)
|
|
:method-count-assert 56
|
|
:size-assert #xb0
|
|
:flag-assert #x38000000b0
|
|
(:methods
|
|
(nav-state-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(nav-state-method-10 () none) ;; 10 ;; (nav-state-method-10 (_type_) none 10)
|
|
(nav-state-method-11 () none) ;; 11 ;; (plan-over-pat1-polys-using-route (_type_ nav-gap-info) symbol 11)
|
|
(nav-state-method-12 () none) ;; 12 ;; (get-velocity (_type_ vector) vector 12)
|
|
(nav-state-method-13 () none) ;; 13 ;; (get-travel (_type_ vector) vector 13)
|
|
(nav-state-method-14 () none) ;; 14 ;; (get-heading (_type_ vector) vector 14)
|
|
(nav-state-method-15 () none) ;; 15 ;; (get-target-post (_type_ vector) vector 15)
|
|
(nav-state-method-16 () none) ;; 16 ;; (get-speed (_type_) meters 16)
|
|
(nav-state-method-17 () none) ;; 17 ;; (get-rotation-rate (_type_) float 17)
|
|
(nav-state-method-18 () none) ;; 18 ;; (try-projecting-to-current-poly (_type_ vector object vector) symbol 18)
|
|
(nav-state-method-19 () none) ;; 19 ;; (get-current-poly (_type_) nav-poly 19)
|
|
(nav-state-method-20 () none) ;; 20 ;; (copy-nav-state! (_type_ (pointer nav-state)) none 20)
|
|
(nav-state-method-21 () none) ;; 21 ;; (nav-state-method-21 () none 21)
|
|
(nav-state-method-22 () none) ;; 22 ;; (nav-state-method-22 () none 22)
|
|
(nav-state-method-23 () none) ;; 23 ;; (nav-state-method-23 () none 23)
|
|
(nav-state-method-24 () none) ;; 24 ;; (turn-and-navigate-to-destination (_type_) none 24)
|
|
(nav-state-method-25 () none) ;; 25 ;; (navigate-using-route-portals-wrapper (_type_) none 25)
|
|
(nav-state-method-26 () none) ;; 26 ;; (navigate-using-best-dir-recompute-avoid-spheres-1-wrapper (_type_) none 26)
|
|
(nav-state-method-27 () none) ;; 27 ;; (navigate-within-poly-wrapper (_type_) none 27)
|
|
(nav-state-method-28 () none) ;; 28 ;; (compute-travel-speed (_type_) none 28)
|
|
(nav-state-method-29 () none) ;; 29 ;; (nav-state-method-29 (_type_) none 29)
|
|
(nav-state-method-30 () none) ;; 30 ;; (nav-state-method-30 (_type_) none 30)
|
|
(nav-state-method-31 () none) ;; 31 ;; (navigate-using-best-dir-recompute-avoid-spheres-2 (_type_) none 31)
|
|
(nav-state-method-32 () none) ;; 32 ;; (update-travel-dir-from-spheres (_type_) none 32)
|
|
(nav-state-method-33 () none) ;; 33 ;; (compute-speed-simple (_type_) none 33)
|
|
(nav-state-method-34 () none) ;; 34 ;; (navigate-v1! (_type_) none 34)
|
|
(nav-state-method-35 () none) ;; 35 ;; (reset-target! (_type_) none 35)
|
|
(nav-state-method-36 () none) ;; 36 ;; (add-offset-to-target! (_type_ vector) none 36)
|
|
(nav-state-method-37 () none) ;; 37 ;; (navigate-v2! (_type_) none 37)
|
|
(nav-state-method-38 () none) ;; 38 ;; (set-current-poly! (_type_ nav-poly) none 38)
|
|
(nav-state-method-39 () none) ;; 39 ;; (nav-state-method-39 (_type_) symbol 39)
|
|
(nav-state-method-40 () none) ;; 40 ;; (do-navigation-to-destination (_type_ vector) none 40)
|
|
(nav-state-method-41 () none) ;; 41 ;; (clamp-vector-to-mesh-cross-gaps (_type_ vector) symbol 41)
|
|
(nav-state-method-42 () none) ;; 42 ;; (set-target-post! (_type_ vector) none 42)
|
|
(nav-state-method-43 () none) ;; 43 ;; (set-travel! (_type_ vector) none 43)
|
|
(nav-state-method-44 () none) ;; 44 ;; (set-velocity! (_type_ vector) none 44)
|
|
(nav-state-method-45 () none) ;; 45 ;; (set-heading! (_type_ vector) none 45)
|
|
(nav-state-method-46 () none) ;; 46 ;; (set-speed! (_type_ meters) none 46)
|
|
(nav-state-method-47 () none) ;; 47 ;; (reset! (_type_ nav-control) none 47)
|
|
(nav-state-method-48 () none) ;; 48 ;; (nav-state-method-48 () none 48)
|
|
(nav-state-method-49 () none) ;; 49 ;; (navigate-using-best-dir-use-existing-avoid-spheres (_type_ nav-avoid-spheres-params) none 49)
|
|
(nav-state-method-50 () none) ;; 50 ;; (nav-state-method-50 (_type_) none 50)
|
|
(nav-state-method-51 () none) ;; 51 ;; (navigate-using-route-portals (_type_) none 51)
|
|
(nav-state-method-52 () none) ;; 52 ;; (navigate-using-best-dir-recompute-avoid-spheres-1 (_type_) none 52)
|
|
(nav-state-method-53 () none) ;; 53 ;; (navigate-within-poly (_type_) none 53)
|
|
(nav-state-method-54 () none) ;; 54 ;; (clamp-travel-vector (_type_) none 54)
|
|
(nav-state-method-55 () none) ;; 55
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-control (structure)
|
|
((flags nav-control-flag :offset-assert 0)
|
|
(callback-info nav-callback-info :offset-assert 4)
|
|
(process process :offset-assert 8) ;; guessed by decompiler
|
|
(pad0 uint32 :offset-assert 12)
|
|
(shape collide-shape :offset-assert 16) ;; guessed by decompiler
|
|
(nearest-y-threshold meters :offset-assert 20)
|
|
(nav-cull-radius meters :offset-assert 24)
|
|
(sec-per-frame float :offset-assert 28)
|
|
(target-speed meters :offset-assert 32)
|
|
(acceleration meters :offset-assert 36)
|
|
(turning-acceleration meters :offset-assert 40)
|
|
(max-rotation-rate float :offset-assert 44)
|
|
(speed-scale float :offset-assert 48)
|
|
(sphere-count int32 :offset-assert 52)
|
|
(sphere-array (inline-array sphere) :offset-assert 56) ;; guessed by decompiler
|
|
(root-sphere-id uint8 :offset-assert 60)
|
|
(sphere-mask uint8 :offset-assert 61)
|
|
(pad1 uint8 2 :offset-assert 62) ;; guessed by decompiler
|
|
(sphere-id-array uint8 16 :offset-assert 64) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(extra-nav-sphere vector :inline :offset-assert 80)
|
|
(root-nav-sphere vector :inline :offset-assert 96)
|
|
(state nav-state :inline :offset-assert 112)
|
|
(mesh basic :offset-assert 124)
|
|
)
|
|
:method-count-assert 47
|
|
:size-assert #x120
|
|
:flag-assert #x2f00000120
|
|
(:methods
|
|
(nav-control-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(nav-control-method-10 () none) ;; 10 ;; (point-in-bsphere? (_type_ vector) symbol 10)
|
|
(nav-control-method-11 () none) ;; 11 ;; (find-poly-containing-point-1 (_type_ vector) nav-poly 11)
|
|
(nav-control-method-12 () none) ;; 12 ;; (cloest-point-on-mesh (_type_ vector vector nav-poly) nav-poly 12)
|
|
(nav-control-method-13 () none) ;; 13 ;; (find-nearest-poly-to-point (_type_ vector) nav-poly 13)
|
|
(nav-control-method-14 () none) ;; 14 ;; (project-point-onto-plane-of-poly (_type_ nav-poly vector vector vector) none 14)
|
|
(nav-control-method-15 () none) ;; 15 ;; (find-poly-containing-point-2 (_type_ vector) nav-poly 15)
|
|
(nav-control-method-16 () none) ;; 16 ;; (is-above-poly-max-height? (_type_ vector float) symbol 16)
|
|
(nav-control-method-17 () none) ;; 17 ;; (is-in-mesh? (_type_ vector float) symbol 17)
|
|
(nav-control-method-18 () none) ;; 18 ;; (avoid-spheres-1! (_type_ nav-avoid-spheres-params) symbol 18)
|
|
(nav-control-method-19 () none) ;; 19 ;; (avoid-spheres-2! (_type_ nav-avoid-spheres-params) symbol 19)
|
|
(nav-control-method-20 () none) ;; 20 ;; (clamp-vector-to-mesh-cross-gaps (_type_ vector nav-poly vector float symbol clamp-travel-vector-to-mesh-return-info) none 20)
|
|
(nav-control-method-21 () none) ;; 21 ;; (clamp-vector-to-mesh-no-gaps (_type_ vector nav-poly vector clamp-travel-vector-to-mesh-return-info) none 21)
|
|
(nav-control-method-22 () none) ;; 22 ;; (find-first-sphere-and-update-avoid-params (_type_ vector nav-avoid-spheres-params) float 22)
|
|
(nav-control-method-23 () none) ;; 23 ;; (set-spheres-from-nav-ids (_type_) none 23)
|
|
(nav-control-method-24 () none) ;; 24 ;; (add-root-sphere-to-hash! (_type_ vector int) symbol 24)
|
|
(nav-control-method-25 () none) ;; 25 ;; (get-max-rotation-rate (_type_) float 25)
|
|
(nav-control-method-26 () none) ;; 26 ;; (get-sphere-mask (_type_) uint 26)
|
|
(nav-control-method-27 () none) ;; 27 ;; (get-target-speed (_type_) meters 27)
|
|
(nav-control-method-28 () none) ;; 28 ;; (enable-extra-sphere! (_type_) none 28)
|
|
(nav-control-method-29 () none) ;; 29 ;; (disable-extra-sphere! (_type_) none 29)
|
|
(nav-control-method-30 () none) ;; 30 ;; (copy-extra-nav-sphere! (_type_ sphere) none 30)
|
|
(nav-control-method-31 () none) ;; 31 ;; (set-extra-nav-sphere-xyz! (_type_ sphere) none 31)
|
|
(nav-control-method-32 () none) ;; 32 ;; (set-extra-nav-sphere-radius! (_type_ float) none 32)
|
|
(nav-control-method-33 () none) ;; 33 ;; (set-nearest-y-thres! (_type_ float) none 33)
|
|
(nav-control-method-34 () none) ;; 34 ;; (set-nav-cull-radius! (_type_ meters) none 34)
|
|
(nav-control-method-35 () none) ;; 35 ;; (set-speed-scale! (_type_ float) none 35)
|
|
(nav-control-method-36 () none) ;; 36 ;; (set-target-speed! (_type_ meters) none 36)
|
|
(nav-control-method-37 () none) ;; 37 ;; (set-acceleration! (_type_ meters) none 37)
|
|
(nav-control-method-38 () none) ;; 38 ;; (set-turning-acceleration! (_type_ meters) none 38)
|
|
(nav-control-method-39 () none) ;; 39 ;; (set-max-rotation-rate! (_type_ float) none 39)
|
|
(nav-control-method-40 () none) ;; 40 ;; (set-sphere-mask! (_type_ uint) none 40)
|
|
(nav-control-method-41 () none) ;; 41 ;; (remove! (_type_) none 41)
|
|
(nav-control-method-42 () none) ;; 42 ;; (init! (_type_ collide-shape) none 42)
|
|
(nav-control-method-43 () none) ;; 43 ;; (display-marks? (_type_) symbol 43)
|
|
(nav-control-method-44 () none) ;; 44 ;; (nav-control-method-44 () none 44)
|
|
(nav-control-method-45 () none) ;; 45 ;; (find-first-sphere-intersecting-ray (_type_ vector vector vector) sphere 45)
|
|
(nav-control-method-46 () none) ;; 46 ;; (find-sphere-ids-from-sphere-hash (_type_ symbol) none 46)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vu1-macros ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-faccar ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-faccar (wcar-base)
|
|
((jmod-axles UNKNOWN 4 :offset-assert 2752)
|
|
(jmod-shock-tops UNKNOWN 4 :offset-assert 2880)
|
|
(jmod-shock-mids UNKNOWN 4 :offset-assert 3008)
|
|
(jmod-antenna UNKNOWN 4 :offset-assert 3264)
|
|
)
|
|
:method-count-assert 204
|
|
:size-assert #xd40
|
|
:flag-assert #xcc0cc00d40
|
|
(:methods
|
|
(v-faccar-method-203 () none) ;; 203
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype faccar (w-parking-spot)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xf8
|
|
:flag-assert #x1b008000f8
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; timer-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype timer-mode (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
#|
|
|
(deftype timer-bank (structure)
|
|
((count uint32 :offset-assert 0)
|
|
(mode timer-mode :offset-assert 16) ;; guessed by decompiler
|
|
(comp uint32 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype timer-hold-bank (timer-bank)
|
|
((hold uint32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype stopwatch (basic)
|
|
((prev-time-elapsed uint64 :offset-assert 8) ;; time-frame
|
|
(start-time uint64 :offset-assert 16) ;; time-frame
|
|
(begin-level int32 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ticks-per-frame* object) ;; int
|
|
;; (define-extern timer-init function) ;; (function timer-bank timer-mode int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sampler ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sampler-mem* object) ;; pointer
|
|
;; (define-extern *sampler-compare* object) ;; uint
|
|
;; (define-extern *sampler-count* object) ;; int
|
|
;; (define-extern timer0-handler function) ;; (function none)
|
|
;; (define-extern sampler-start function) ;; (function none)
|
|
;; (define-extern sampler-stop function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vector-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bit-array (basic)
|
|
((length int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #xd
|
|
:flag-assert #xd0000000d
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(bit-array-method-9 () none) ;; 9 ;; (get-bit (_type_ int) symbol 9)
|
|
(bit-array-method-10 () none) ;; 10 ;; (clear-bit (_type_ int) int 10)
|
|
(bit-array-method-11 () none) ;; 11 ;; (set-bit (_type_ int) int 11)
|
|
(bit-array-method-12 () none) ;; 12 ;; (clear-all! (_type_) _type_ 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector16ub (structure)
|
|
((data uint8 16 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4ub (structure)
|
|
((data uint8 4 :offset-assert 0) ;; guessed by decompiler
|
|
(x uint8 :offset-assert 0)
|
|
(y uint8 :offset-assert 1)
|
|
(z uint8 :offset-assert 2)
|
|
(w uint8 :offset-assert 3)
|
|
(clr uint32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4b (structure)
|
|
((data int8 4 :offset-assert 0) ;; guessed by decompiler
|
|
(x int8 :offset-assert 0)
|
|
(y int8 :offset-assert 1)
|
|
(z int8 :offset-assert 2)
|
|
(w int8 :offset-assert 3)
|
|
(clr int32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector2ub (structure)
|
|
((data uint8 2 :offset-assert 0) ;; guessed by decompiler
|
|
(x uint8 :offset-assert 0)
|
|
(y uint8 :offset-assert 1)
|
|
(clr uint16 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector2b (structure)
|
|
((data int8 2 :offset-assert 0) ;; guessed by decompiler
|
|
(x int8 :offset-assert 0)
|
|
(y int8 :offset-assert 1)
|
|
(clr int16 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector2h (structure)
|
|
((data int16 2 :offset-assert 0) ;; guessed by decompiler
|
|
(x int16 :offset-assert 0)
|
|
(y int16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector2uh (structure)
|
|
((data uint16 2 :offset-assert 0) ;; guessed by decompiler
|
|
(x uint16 :offset-assert 0)
|
|
(y uint16 :offset-assert 2)
|
|
(val uint32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector3h (structure)
|
|
((data int16 3 :offset-assert 0) ;; guessed by decompiler
|
|
(x int16 :offset-assert 0)
|
|
(y int16 :offset-assert 2)
|
|
(z int16 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector3uh (structure)
|
|
((data uint16 3 :offset-assert 0) ;; guessed by decompiler
|
|
(x uint16 :offset-assert 0)
|
|
(y uint16 :offset-assert 2)
|
|
(z uint16 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector2w (structure)
|
|
((data int32 2 :offset-assert 0) ;; guessed by decompiler
|
|
(x int32 :offset-assert 0)
|
|
(y int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector3w (structure)
|
|
((data int32 3 :offset-assert 0) ;; guessed by decompiler
|
|
(x int32 :offset-assert 0)
|
|
(y int32 :offset-assert 4)
|
|
(z int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4w (structure)
|
|
((data int32 4 :offset-assert 0) ;; guessed by decompiler
|
|
(x int32 :offset-assert 0)
|
|
(y int32 :offset-assert 4)
|
|
(z int32 :offset-assert 8)
|
|
(w int32 :offset-assert 12)
|
|
(dword uint64 2 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector2 (structure)
|
|
((data float 2 :offset-assert 0) ;; guessed by decompiler
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector3 (structure)
|
|
((data float 3 :offset-assert 0) ;; guessed by decompiler
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(z float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4 (structure)
|
|
((data float 4 :offset-assert 0) ;; guessed by decompiler
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(z float :offset-assert 8)
|
|
(w float :offset-assert 12)
|
|
(dword uint64 2 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4w-2 (structure)
|
|
((data int32 8 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 2 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector4w 2 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4w-3 (structure)
|
|
((data int32 12 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 3 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector4w 3 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4w-4 (structure)
|
|
((data int32 16 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 4 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector4w 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4h (structure)
|
|
((data int16 4 :offset-assert 0) ;; guessed by decompiler
|
|
(x int16 :offset-assert 0)
|
|
(y int16 :offset-assert 2)
|
|
(z int16 :offset-assert 4)
|
|
(w int16 :offset-assert 6)
|
|
(long uint64 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector8h (structure)
|
|
((data int16 8 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector16b (structure)
|
|
((data int8 16 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector4s-3 (structure)
|
|
((data float 12 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 3 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 3 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector-array (inline-array-class)
|
|
((data vector :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rgbaf (vector)
|
|
((r float :offset-assert 0)
|
|
(g float :offset-assert 4)
|
|
(b float :offset-assert 8)
|
|
(a float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype plane (vector)
|
|
((a float :offset-assert 0)
|
|
(b float :offset-assert 4)
|
|
(c float :offset-assert 8)
|
|
(d float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sphere (vector)
|
|
((r float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (deftype isphere (vec4s)
|
|
;; ()
|
|
;; :flag-assert #x900000010
|
|
;; )
|
|
|
|
#|
|
|
(deftype box8s (structure)
|
|
((data float 8 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 2 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 2 :offset-assert 0) ;; guessed by decompiler
|
|
(min vector :inline :offset-assert 0)
|
|
(max vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype box8s-array (inline-array-class)
|
|
((data box8s :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vertical-planes (structure)
|
|
((data uint128 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vertical-planes-array (basic)
|
|
((length uint32 :offset-assert 4)
|
|
(data vertical-planes :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype qword (structure)
|
|
((data uint32 4 :offset-assert 0) ;; guessed by decompiler
|
|
(byte uint8 16 :offset-assert 0) ;; guessed by decompiler
|
|
(hword uint16 8 :offset-assert 0) ;; guessed by decompiler
|
|
(word uint32 4 :offset-assert 0) ;; guessed by decompiler
|
|
(dword uint64 2 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
(vector vector :inline :offset-assert 0)
|
|
(vector4w vector4w :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vector3s (structure)
|
|
((data float 3 :offset-assert 0) ;; guessed by decompiler
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(z float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; vector is already defined!
|
|
|
|
;; (define-extern *null-vector* object) ;; vector
|
|
;; (define-extern *identity-vector* object) ;; vector
|
|
;; (define-extern *x-vector* object) ;; vector
|
|
;; (define-extern *y-vector* object) ;; vector
|
|
;; (define-extern *z-vector* object) ;; vector
|
|
;; (define-extern *up-vector* object) ;; vector
|
|
;; (define-extern vector-dot function) ;; (function vector vector float)
|
|
;; (define-extern vector-dot-vu function) ;; (function vector vector float)
|
|
;; (define-extern vector4-dot function) ;; (function vector vector float)
|
|
;; (define-extern vector4-dot-vu function) ;; (function vector vector float)
|
|
;; (define-extern vector+! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-zero! function) ;; (function vector vector)
|
|
;; (define-extern vector-reset! function) ;; (function vector vector)
|
|
;; (define-extern vector-copy! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-length< function) ;; (function vector float symbol)
|
|
;; (define-extern vector-length> function) ;; (function vector float symbol)
|
|
;; (define-extern *zero-vector* object) ;; vector
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; math ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype float-type (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype rgba (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype xyzw (uint128)
|
|
;; ()
|
|
;; :flag-assert #x900000010
|
|
;; )
|
|
|
|
;; (deftype xyzwh (uint128)
|
|
;; ()
|
|
;; :flag-assert #x900000010
|
|
;; )
|
|
|
|
#|
|
|
(deftype random-generator (basic)
|
|
((seed uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern truncate function) ;; (function float float)
|
|
;; (define-extern round function)
|
|
;; (define-extern floor function) ;; (function float float)
|
|
;; (define-extern ceil function) ;; (function float float)
|
|
;; (define-extern integral? function) ;; (function float symbol)
|
|
;; (define-extern fractional-part function) ;; (function float float)
|
|
;; (define-extern odd? function) ;; (function int symbol)
|
|
;; (define-extern even? function) ;; (function int symbol)
|
|
;; (define-extern sawtooth-wave function) ;; (function float float)
|
|
;; (define-extern triangle-wave function) ;; (function float float)
|
|
;; (define-extern log-x-plus-1-order9 function) ;; (function float float)
|
|
;; (define-extern logf function) ;; (function float float)
|
|
;; (define-extern log2f function) ;; (function float float)
|
|
;; (define-extern exp-slead object) ;; (pointer float)
|
|
;; (define-extern exp-strail object) ;; (pointer float)
|
|
;; (define-extern exp function) ;; (function float float)
|
|
;; (define-extern pow function) ;; (function float float float)
|
|
;; (define-extern print-exp function) ;; (function float none)
|
|
;; (define-extern print-time function) ;; (function object time-frame none)
|
|
;; (define-extern log2 function) ;; (function int int)
|
|
;; (define-extern seek function) ;; (function float float float float)
|
|
;; (define-extern seek-ease function) ;; (function float float float float float float)
|
|
;; (define-extern seek-ease-in-out function) ;; (function float float float float float float float float)
|
|
;; (define-extern lerp function) ;; (function float float float float)
|
|
;; (define-extern lerp-scale-old function) ;; (function float float float float float float)
|
|
;; (define-extern lerp-scale function) ;; (function float float float float float float)
|
|
;; (define-extern lerp-scale-clamp function)
|
|
;; (define-extern lerp-clamp function) ;; (function float float float float)
|
|
;; (define-extern rgba-lerp function) ;; (function rgba rgba rgba rgba)
|
|
;; (define-extern seekl function) ;; (function int int int int)
|
|
;; (define-extern rand-vu-init function) ;; (function float float)
|
|
;; (define-extern rand-vu function) ;; (function float)
|
|
;; (define-extern rand-vu-nostep function) ;; (function float)
|
|
;; (define-extern rand-vu-float-range function) ;; (function float float float)
|
|
;; (define-extern rand-vu-percent? function) ;; (function float symbol)
|
|
;; (define-extern rand-vu-int-range function) ;; (function int int int)
|
|
;; (define-extern rand-vu-int-count function) ;; (function int int)
|
|
;; (define-extern rand-vu-int-count-excluding function) ;; (function int int int)
|
|
;; (define-extern rand-vu-int-range-exclude function) ;; (function int int int int)
|
|
;; (define-extern *random-generator* object) ;; random-generator
|
|
;; (define-extern rand-uint31-gen function) ;; (function random-generator uint)
|
|
;; (define-extern cube-root function) ;; (function float float)
|
|
;; (define-extern int-noise function) ;; (function int float)
|
|
;; (define-extern smooth-step function) ;; (function float float)
|
|
;; (define-extern smooth-interp function) ;; (function float float float float float float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gravity-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dma ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern dma-sync-hang function) ;; (function dma-bank none)
|
|
;; (define-extern dma-sync-crash function) ;; (function dma-bank none)
|
|
;; (define-extern dma-send function) ;; (function dma-bank uint uint none)
|
|
;; (define-extern dma-send-chain function) ;; (function dma-bank-source uint none)
|
|
;; (define-extern dma-send-chain-no-tte function) ;; (function dma-bank-source uint none)
|
|
;; (define-extern dma-send-chain-no-flush function) ;; (function dma-bank-source uint none)
|
|
;; (define-extern dma-send-to-spr function) ;; (function uint uint uint symbol none)
|
|
;; (define-extern dma-send-to-spr-no-flush function) ;; (function uint uint uint symbol none)
|
|
;; (define-extern dma-send-from-spr function) ;; (function uint uint uint symbol none)
|
|
;; (define-extern dma-send-from-spr-no-flush function) ;; (function uint uint uint symbol none)
|
|
;; (define-extern dma-initialize function) ;; (function none)
|
|
;; (define-extern clear-vu0-mem function) ;; (function none)
|
|
;; (define-extern clear-vu1-mem function) ;; (function none)
|
|
;; (define-extern dump-vu1-mem function) ;; (function none)
|
|
;; (define-extern dump-vu1-range function) ;; (function uint uint symbol)
|
|
;; (define-extern reset-vif1-path function) ;; (function none)
|
|
;; (define-extern ultimate-memcpy function) ;; (function pointer pointer uint none)
|
|
;; (define-extern symlink2 function) ;; (function none)
|
|
;; (define-extern symlink3 function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mech-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mech-info (basic)
|
|
((entity basic :offset-assert 4)
|
|
(hud handle 1 :offset-assert 8) ;; guessed by decompiler
|
|
(mech-trans vector :inline :offset-assert 16)
|
|
(mech-quat vector :inline :offset-assert 32)
|
|
(mech-scale vector :inline :offset-assert 48)
|
|
(engine-sound-id sound-id :offset-assert 64) ;; guessed by decompiler
|
|
(engine-sound-volume float :offset-assert 68)
|
|
(engine-sound-pitch float :offset-assert 72)
|
|
(thrust-sound-id sound-id :offset-assert 76) ;; guessed by decompiler
|
|
(drag-sound-id sound-id :offset-assert 80) ;; guessed by decompiler
|
|
(whine-sound-id sound-id :offset-assert 84) ;; guessed by decompiler
|
|
(shield-sound-id uint32 :offset-assert 88)
|
|
(mech-start-time uint64 :offset-assert 96) ;; time-frame
|
|
(mech-time uint64 :offset-assert 104) ;; time-frame
|
|
(no-get-off-time uint64 :offset-assert 112) ;; time-frame
|
|
(stick-lock basic :offset-assert 120)
|
|
(stick-off basic :offset-assert 124)
|
|
(forward-vel meters :offset-assert 128)
|
|
(jump-thrust meters :offset-assert 132)
|
|
(jump-thrust-fuel float :offset-assert 136)
|
|
(unstuck-time uint64 :offset-assert 144) ;; time-frame
|
|
(stuck-count int32 :offset-assert 152)
|
|
(back-touch-point vector :inline :offset-assert 160)
|
|
(back-touch-trans vector :inline :offset-assert 176)
|
|
(back-touch-time uint64 :offset-assert 192) ;; time-frame
|
|
(attack-id uint32 :offset-assert 200)
|
|
(shield-value float :offset-assert 204)
|
|
(shield-max float :offset-assert 208)
|
|
(shield-handle uint64 :offset-assert 216)
|
|
(walk-anim-leg int32 :offset-assert 224)
|
|
(state-impact? symbol 1 :offset-assert 228) ;; guessed by decompiler
|
|
(state-impact impact-control 1 :offset-assert 240) ;; guessed by decompiler
|
|
(thruster-flame-width meters :offset-assert 320)
|
|
(thruster-flame-length meters :offset-assert 324)
|
|
(thruster-local-pos vector 2 :offset-assert 336) ;; guessed by decompiler
|
|
(exhaust-local-pos vector 2 :offset-assert 368) ;; guessed by decompiler
|
|
(exhaust-local-dir vector 2 :offset-assert 400) ;; guessed by decompiler
|
|
(smoke-local-pos vector 2 :offset-assert 432) ;; guessed by decompiler
|
|
(smoke-local-vel vector 2 :offset-assert 464) ;; guessed by decompiler
|
|
(particle-system-2d basic :offset-assert 496)
|
|
(particle-system-3d basic :offset-assert 500)
|
|
(part-thruster basic :offset-assert 504)
|
|
(part-thruster-scale-x sp-field-init-spec :offset-assert 508)
|
|
(part-thruster-scale-y sp-field-init-spec :offset-assert 512)
|
|
(part-quat quaternion :offset-assert 516)
|
|
(part-vel vector :offset-assert 520)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20c
|
|
:flag-assert #x90000020c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *mech-shadow-control* shadow-control) ;; shadow-control
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tie ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tie-consts (structure)
|
|
((data uint32 40 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 10 :offset-assert 0) ;; guessed by decompiler
|
|
(quads uint128 10 :offset-assert 0) ;; guessed by decompiler
|
|
(adgif qword :inline :offset-assert 0) ;; gs-gif-tag :inline
|
|
(strgif qword :inline :offset-assert 16) ;; gs-gif-tag :inline
|
|
(extra qword :inline :offset-assert 32) ;; vector :inline
|
|
(gifbufs qword :inline :offset-assert 48) ;; vector :inline
|
|
(clrbufs qword :inline :offset-assert 64)
|
|
(misc qword :inline :offset-assert 80)
|
|
(atestgif qword :inline :offset-assert 96) ;; gs-gif-tag :inline
|
|
(alpha qword :inline :offset-assert 112) ;; gs-adcmd :inline
|
|
(atest gs-adcmd 2 :offset-assert 128) ;; guessed by decompiler
|
|
(atest-tra gs-adcmd :inline :offset-assert 128)
|
|
(atest-def gs-adcmd :inline :offset-assert 144)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa0
|
|
:flag-assert #x9000000a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype drawable-inline-array-instance-tie (drawable-inline-array)
|
|
((length int16 :offset-assert 2)
|
|
(data instance-tie :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x64
|
|
:flag-assert #x1100000064
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-tie (drawable-inline-array)
|
|
((length int16 :offset-assert 2)
|
|
(data tie-fragment :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x64
|
|
:flag-assert #x1100000064
|
|
)
|
|
|#
|
|
|
|
;; (define-extern tie-vu1-block object) ;; vu-function
|
|
;; (define-extern tie-init-consts function) ;; (function tie-consts gs-alpha gs-test gs-test none)
|
|
;; (define-extern tie-init-engine function) ;; (function dma-buffer gs-alpha gs-test gs-test none)
|
|
;; (define-extern tie-end-buffer function) ;; (function dma-buffer none)
|
|
;; (define-extern tie-int-reg function) ;; (function int string)
|
|
;; (define-extern tie-float-reg function) ;; (function int string)
|
|
;; (define-extern tie-ints function) ;; (function none)
|
|
;; (define-extern tie-floats function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; neo-grenadier ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bank-info (structure)
|
|
((circle sphere :inline :offset-assert 0)
|
|
(tangent-pos vector :inline :offset-assert 16)
|
|
(final-pos vector :inline :offset-assert 32)
|
|
(final-dir vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-grenadier (nav-enemy)
|
|
((shot-trajectory trajectory :inline :offset-assert 624)
|
|
(hostile-path basic :offset-assert 664)
|
|
(bank bank-info :inline :offset-assert 672)
|
|
(joint joint-mod-blend-world :offset-assert 736)
|
|
(heading basic :offset-assert 740)
|
|
(move-pos vector :inline :offset-assert 752)
|
|
(move-angle float :offset-assert 768)
|
|
(status-flags uint64 :offset-assert 776)
|
|
(suppress-knockaside-timer uint64 :offset-assert 784)
|
|
)
|
|
:method-count-assert 196
|
|
:size-assert #x318
|
|
:flag-assert #xc402a00318
|
|
(:methods
|
|
(neo-grenadier-method-193 () none) ;; 193
|
|
(neo-grenadier-method-194 () none) ;; 194
|
|
(neo-grenadier-method-195 () none) ;; 195
|
|
)
|
|
(:state-methods
|
|
active ;; 34
|
|
notice ;; 35
|
|
hostile ;; 38
|
|
attack ;; 190
|
|
hit ;; 30
|
|
backup ;; 191
|
|
victory ;; 39
|
|
spin-kick ;; 192
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-neo-grenadier-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *neo-grenadier-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern pos-rotate-y<-vector+vector function) ;; (function vector vector float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; matrix-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype matrix (structure)
|
|
((data float 16 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 4 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 4 :offset-assert 0) ;; guessed by decompiler
|
|
(rvec vector :inline :offset-assert 0)
|
|
(uvec vector :inline :offset-assert 16)
|
|
(fvec vector :inline :offset-assert 32)
|
|
(trans vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x40
|
|
:flag-assert #xa00000040
|
|
(:methods
|
|
(matrix-method-9 () none) ;; 9 ;; (transform-vectors! (_type_ (inline-array vector) (inline-array vector) int) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype matrix3 (structure)
|
|
((data float 12 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 3 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 3 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype matrix4h (structure)
|
|
((data int16 16 :offset-assert 0) ;; guessed by decompiler
|
|
(vector4h vector4h 4 :offset-assert 0) ;; guessed by decompiler
|
|
(long int64 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
;; (define-extern matrix-copy! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix<-vector-yz-exact! function)
|
|
;; (define-extern matrix<-vector-yz! function)
|
|
;; (define-extern matrix<-vector-z! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flee-info ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flee-info (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; powerups ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cloud-track function) ;; (function process-tree process-tree (function vector none) time-frame time-frame time-frame none :behavior process)
|
|
;; (define-extern eco-blue-glow function) ;; (function vector none)
|
|
;; (define-extern target-eco-process function) ;; (function none :behavior target)
|
|
;; (define-extern target-color-effect-process function) ;; (function none :behavior target)
|
|
;; (define-extern target-update-segs function)
|
|
;; (define-extern target-draw-process function)
|
|
;; (define-extern target-powerup-process function) ;; (function none :behavior target)
|
|
;; (define-extern target-powerup-effect function) ;; (function symbol none :behavior target)
|
|
;; (define-extern process-contact-action function) ;; (function process none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gekko ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gekko-foot-info (structure)
|
|
((ground-pos vector :inline :offset-assert 0)
|
|
(ground-normal vector :inline :offset-assert 16)
|
|
(foot-transform transformq :inline :offset-assert 32)
|
|
(leg-ik basic :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x54
|
|
:flag-assert #x900000054
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gekko-ik-setup (structure)
|
|
((elbow-index int32 :offset-assert 0)
|
|
(hand-index int32 :offset-assert 4)
|
|
(effector-index int32 :offset-assert 8)
|
|
(hand-dist float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gekko-shadow-spot (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(normal vector :inline :offset-assert 16)
|
|
(valid? basic :offset-assert 32)
|
|
(pat uint32 :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gekko (nav-enemy)
|
|
((shadow-spot gekko-shadow-spot :inline :offset-assert 620)
|
|
(foot UNKNOWN 4 :offset-assert 668)
|
|
(rot-matrix matrix :inline :offset-assert 1052)
|
|
(gspot-normal vector :inline :offset-assert 1116)
|
|
(tilt-quat quaternion :inline :offset-assert 1132)
|
|
(dest-to-me-dir vector :inline :offset-assert 1148)
|
|
(turn-face-point vector :inline :offset-assert 1164)
|
|
(flags gekko-flag :offset-assert 1180)
|
|
(attack-time uint64 :offset-assert 1188)
|
|
(last-turn-time uint64 :offset-assert 1196)
|
|
(fade float :offset-assert 1204)
|
|
(rot-mult float :offset-assert 1208)
|
|
(move-speed float :offset-assert 1212)
|
|
(move-decel float :offset-assert 1216)
|
|
(turn-next-state basic :offset-assert 1220)
|
|
(path-wall basic :offset-assert 1224)
|
|
(scared-timer uint64 :offset-assert 1228)
|
|
(scale float :offset-assert 1236)
|
|
(probe-len float :offset-assert 1240)
|
|
)
|
|
:method-count-assert 209
|
|
:size-assert #x4e0
|
|
:flag-assert #xd1046004e0
|
|
;; field gekko-flag is likely a value type.
|
|
(:methods
|
|
(gekko-method-202 () none) ;; 202
|
|
(gekko-method-203 () none) ;; 203
|
|
(gekko-method-204 () none) ;; 204
|
|
(gekko-method-205 () none) ;; 205
|
|
(gekko-method-206 () none) ;; 206
|
|
(gekko-method-207 () none) ;; 207
|
|
(gekko-method-208 () none) ;; 208
|
|
)
|
|
(:state-methods
|
|
attack-wall ;; 193
|
|
idle ;; 33
|
|
active-wall ;; 190
|
|
jump-off-wall ;; 195
|
|
notice ;; 35
|
|
hostile-wall ;; 191
|
|
turn-wall ;; 192
|
|
knocked-wall ;; 194
|
|
jump-off-wall-falling ;; 196
|
|
jump-off-wall-recover ;; 197
|
|
active ;; 34
|
|
stare ;; 37
|
|
flee ;; 36
|
|
hostile ;; 38
|
|
pre-attack ;; 198
|
|
attack ;; 199
|
|
turn ;; 200
|
|
turn-quick ;; 201
|
|
jump ;; 44
|
|
knocked ;; 31
|
|
knocked-recover ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gecko (gekko)
|
|
()
|
|
:method-count-assert 209
|
|
:size-assert #x4e0
|
|
:flag-assert #xd1046004e0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *gekko-ik-setup* object)
|
|
;; (define-extern *gekko-foot-offset* array)
|
|
;; (define-extern *fact-info-gekko-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *gekko-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern hostile-wall-trans function)
|
|
;; (define-extern gekko-stare-code function)
|
|
;; (define-extern gekko-foot-rot-handler function)
|
|
;; (define-extern gekko-postbind function)
|
|
;; (define-extern gekko-postbind-callback function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-effects ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern calc-fade-vals function) ;; (function float none)
|
|
;; (define-extern *vehicle-headlight-glow-template* object) ;; sprite-glow-data
|
|
;; (define-extern *vehicle-taillight-glow-template* object) ;; sprite-glow-data
|
|
;; (define-extern *vehicle-thruster-glow-template* object) ;; sprite-glow-data
|
|
;; (define-extern *vehicle-particle-common-info* object)
|
|
;; (define-extern vehicle-draw-thruster function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nst-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-color-ceiling-dust* curve-color-fast)
|
|
;; (define-extern *range-alpha-ceiling-dust* curve2d-fast)
|
|
;; (define-extern *range-scale-ceiling-dust-x* curve2d-fast)
|
|
;; (define-extern *range-scale-ceiling-dust-y* curve2d-fast)
|
|
;; (define-extern *curve-alpha-ceiling-dust* curve2d-fast)
|
|
;; (define-extern *curve-ceiling-dust-x* curve2d-fast)
|
|
;; (define-extern *curve-ceiling-dust-y* curve2d-fast)
|
|
;; (define-extern *part-nest-ceiling-dust-curve-settings* object)
|
|
;; (define-extern birth-func-find-ground function)
|
|
;; (define-extern spt-func-check-hit-ground function)
|
|
;; (define-extern *range-color-ground-impact-dust* curve-color-fast)
|
|
;; (define-extern *range-alpha-ground-impact-dust* curve2d-fast)
|
|
;; (define-extern *range-scale-ground-impact-dust-x* curve2d-fast)
|
|
;; (define-extern *range-scale-ground-impact-dust-y* curve2d-fast)
|
|
;; (define-extern *curve-alpha-ground-impact-dust* curve2d-fast)
|
|
;; (define-extern *curve-ground-impact-dust-x* curve2d-fast)
|
|
;; (define-extern *curve-ground-impact-dust-y* curve2d-fast)
|
|
;; (define-extern *part-nest-ground-impact-dust-curve-settings* object)
|
|
;; (define-extern part-nest-bat1-path function)
|
|
;; (define-extern part-nest-bat2-path function)
|
|
;; (define-extern part-nest-bat3-path function)
|
|
;; (define-extern part-nest-bat4-path function)
|
|
;; (define-extern part-nest-bat5-path function)
|
|
;; (define-extern part-nest-bat6-path function)
|
|
;; (define-extern part-nest-bat7-path function)
|
|
;; (define-extern part-nest-bat8-path function)
|
|
;; (define-extern part-nest-bat9-path function)
|
|
;; (define-extern part-nest-bat10-path function)
|
|
;; (define-extern *range-nst-splash-color* curve-color-fast)
|
|
;; (define-extern *range-nst-splash-alpha* curve2d-fast)
|
|
;; (define-extern *range-nst-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-nst-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-nst-splash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-nst-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-nst-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-bridge-break-splash-curve-settings* object)
|
|
;; (define-extern birth-func-nstb-set-height-and-curve function)
|
|
;; (define-extern birth-func-nstb-set-height function)
|
|
;; (define-extern birth-func-nstb-set-height-and-texture-group function)
|
|
;; (define-extern *range-color-cocoon-poison-gas* curve-color-fast)
|
|
;; (define-extern *range-alpha-cocoon-poison-gas* curve2d-fast)
|
|
;; (define-extern *range-scale-cocoon-poison-gas-x* curve2d-fast)
|
|
;; (define-extern *range-scale-cocoon-poison-gas-y* curve2d-fast)
|
|
;; (define-extern *r-curve-cocoon-poison-gas* curve2d-fast)
|
|
;; (define-extern *g-curve-cocoon-poison-gas* curve2d-fast)
|
|
;; (define-extern *b-curve-cocoon-poison-gas* curve2d-fast)
|
|
;; (define-extern *curve-alpha-cocoon-poison-gas* curve2d-fast)
|
|
;; (define-extern *curve-cocoon-poison-gas-x* curve2d-fast)
|
|
;; (define-extern *curve-cocoon-poison-gas-y* curve2d-fast)
|
|
;; (define-extern *part-cocoon-poison-gas-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; quaternion-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype quaternion (structure)
|
|
((data float 4 :offset-assert 0) ;; guessed by decompiler
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(z float :offset-assert 8)
|
|
(w float :offset-assert 12)
|
|
(vec vector :inline :offset-assert 0)
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *unity-quaternion* object) ;; quaternion
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; glist-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype glst-node (structure)
|
|
((next glst-node :offset-assert 0)
|
|
(prev glst-node :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype glst-named-node (glst-node)
|
|
((privname string :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype glst-list (structure)
|
|
((head glst-node :offset-assert 0)
|
|
(tail glst-node :offset-assert 4)
|
|
(tailpred glst-node :offset-assert 8)
|
|
(numelem int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern glst-next function) ;; (function glst-node glst-node)
|
|
;; (define-extern glst-prev function) ;; (function glst-node glst-node)
|
|
;; (define-extern glst-head function) ;; (function glst-list glst-node)
|
|
;; (define-extern glst-tail function) ;; (function glst-list glst-node)
|
|
;; (define-extern glst-end-of-list? function) ;; (function glst-node symbol)
|
|
;; (define-extern glst-start-of-list? function) ;; (function glst-node symbol)
|
|
;; (define-extern glst-empty? function) ;; (function glst-list symbol)
|
|
;; (define-extern glst-node-name function) ;; (function glst-named-node string)
|
|
;; (define-extern glst-set-name! function) ;; (function glst-named-node string string)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desertd-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dma-disasm ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vif-disasm-element (structure)
|
|
((mask uint32 :offset-assert 0)
|
|
(tag vif-cmd-32 :offset-assert 4) ;; guessed by decompiler
|
|
(val uint32 :offset-assert 8)
|
|
(print uint32 :offset-assert 12)
|
|
(string1 string :offset-assert 16) ;; guessed by decompiler
|
|
(string2 string :offset-assert 20) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *vif-disasm-table* array) ;; (array vif-disasm-element)
|
|
;; (define-extern disasm-vif-details function) ;; (function symbol (pointer uint8) vif-cmd int symbol)
|
|
;; (define-extern disasm-vif-tag function) ;; (function (pointer vif-tag) int symbol symbol int)
|
|
;; (define-extern disasm-dma-tag function) ;; (function dma-tag symbol none)
|
|
;; (define-extern *dma-disasm* object) ;; symbol
|
|
;; (define-extern disasm-dma-list function) ;; (function dma-packet symbol symbol symbol int symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-edge-grab-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pilot-edge-grab-info (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(local-dir vector :inline :offset-assert 16)
|
|
(handle uint64 :offset-assert 32) ;; handle
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype edge-grab-info (structure)
|
|
((world-vertex vector 8 :offset-assert 0) ;; guessed by decompiler
|
|
(local-vertex vector 8 :offset-assert 128) ;; guessed by decompiler
|
|
(status uint64 :offset-assert 256)
|
|
(actor-cshape-prim-offset int32 :offset-assert 264)
|
|
(actor-handle uint64 :offset-assert 272) ;; handle
|
|
(hanging-matrix matrix :inline :offset-assert 288)
|
|
(edge-vertex vector 2 :offset-assert 0) ;; guessed by decompiler
|
|
(center-hold vector :inline :offset-assert 32)
|
|
(tri-vertex vector 3 :offset-assert 48) ;; guessed by decompiler
|
|
(adjacent-edge-left-vertex vector :inline :offset-assert 96)
|
|
(adjacent-edge-right-vertex vector :inline :offset-assert 112)
|
|
(left-hand-hold vector :inline :offset-assert 352)
|
|
(right-hand-hold vector :inline :offset-assert 368)
|
|
(center-hold-old vector :inline :offset-assert 384)
|
|
(edge-tri-pat uint32 :offset-assert 400)
|
|
(found-edge? symbol :offset-assert 404) ;; guessed by decompiler
|
|
(pilot-edge-grab? symbol :offset-assert 408) ;; guessed by decompiler
|
|
(pilot-edge-grab pilot-edge-grab-info :inline :offset-assert 416)
|
|
(pilot-start-grab-pos vector :inline :offset-assert 464)
|
|
(pilot-grab-interp float :offset-assert 480)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x1e4
|
|
:flag-assert #xb000001e4
|
|
(:methods
|
|
(edge-grab-info-method-9 () none) ;; 9 ;; (edge-grab-info-method-9 (_type_) symbol 9)
|
|
(edge-grab-info-method-10 () none) ;; 10 ;; (debug-draw (_type_) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-edge-tri (structure)
|
|
((ctri collide-cache-tri :offset-assert 0) ;; guessed by decompiler
|
|
(normal vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-edge-edge (structure)
|
|
((ignore basic :offset-assert 0)
|
|
(etri collide-edge-tri :offset-assert 4)
|
|
(vertex-ptr (inline-array vector) 2 :offset-assert 8) ;; guessed by decompiler
|
|
(outward vector :inline :offset-assert 16)
|
|
(edge-vec-norm vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x30
|
|
:flag-assert #xa00000030
|
|
(:methods
|
|
(collide-edge-edge-method-9 () none) ;; 9 ;; (no-collision-at-edge (_type_ collide-edge-work edge-grab-info) symbol 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-edge-hold-item (structure)
|
|
((next collide-edge-hold-item :offset-assert 0)
|
|
(rating float :offset-assert 4)
|
|
(split int8 :offset-assert 8)
|
|
(edge collide-edge-edge :offset-assert 12)
|
|
(center-pt vector :inline :offset-assert 16)
|
|
(outward-pt vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-edge-hold-list (structure)
|
|
((num-allocs uint32 :offset-assert 0)
|
|
(num-attempts uint32 :offset-assert 4)
|
|
(head collide-edge-hold-item :offset-assert 8)
|
|
(items collide-edge-hold-item 32 :offset-assert 16) ;; guessed by decompiler
|
|
(attempts qword 32 :offset-assert 1552) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x810
|
|
:flag-assert #xb00000810
|
|
(:methods
|
|
(collide-edge-hold-list-method-9 () none) ;; 9 ;; (debug-draw (_type_) object 9)
|
|
(collide-edge-hold-list-method-10 () none) ;; 10 ;; (add-to-list! (_type_ collide-edge-hold-item) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-edge-spec (structure)
|
|
((split-dists float 2 :offset-assert 0) ;; guessed by decompiler
|
|
(outward-offset vector :inline :offset-assert 16)
|
|
(flags uint64 :offset-assert 32) ;; collide-edge-spec-flags
|
|
(ignore-pat pat-surface :offset-assert 40) ;; guessed by decompiler
|
|
(max-dist-sqrd-to-outward-pt float :offset-assert 44)
|
|
(max-dir-cosa-delta float :offset-assert 48)
|
|
(max-dir-cosa-player float :offset-assert 52)
|
|
(touching-segment symbol :offset-assert 56) ;; guessed by decompiler
|
|
(local-cache-fill-box bounding-box :inline :offset-assert 64)
|
|
(local-within-reach-box bounding-box :inline :offset-assert 96)
|
|
(local-player-spheres sphere 12 :offset-assert 128) ;; guessed by decompiler
|
|
(local-player-hanging-spheres sphere 6 :offset-assert 128) ;; guessed by decompiler
|
|
(local-player-leap-up-spheres sphere 6 :offset-assert 224) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x140
|
|
:flag-assert #x900000140
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-edge-work (structure)
|
|
((ccache collide-cache :offset-assert 0) ;; guessed by decompiler
|
|
(cshape collide-shape :offset-assert 4) ;; guessed by decompiler
|
|
(num-verts uint32 :offset-assert 8)
|
|
(num-edges uint32 :offset-assert 12)
|
|
(num-tris uint32 :offset-assert 16)
|
|
(cache-fill-box bounding-box :inline :offset-assert 32)
|
|
(within-reach-box bounding-box :inline :offset-assert 64)
|
|
(within-reach-box4w bounding-box4w :inline :offset-assert 96)
|
|
(search-pt vector :inline :offset-assert 128)
|
|
(search-dir-vec vector :inline :offset-assert 144)
|
|
(world-player-spheres sphere 12 :offset-assert 160) ;; guessed by decompiler
|
|
(world-player-hanging-spheres sphere 6 :offset-assert 160) ;; guessed by decompiler
|
|
(world-player-leap-up-spheres sphere 6 :offset-assert 256) ;; guessed by decompiler
|
|
(spec collide-edge-spec :inline :offset-assert 352)
|
|
(process (pointer process-drawable) :offset-assert 672) ;; guessed by decompiler
|
|
(verts vector 64 :offset-assert 688) ;; guessed by decompiler
|
|
(edges collide-edge-edge 96 :offset-assert 1712) ;; guessed by decompiler
|
|
(tris collide-edge-tri 48 :offset-assert 6320) ;; guessed by decompiler
|
|
(hold-list collide-edge-hold-list :inline :offset-assert 7856)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x26c0
|
|
:flag-assert #x15000026c0
|
|
(:methods
|
|
(collide-edge-work-method-9 () none) ;; 9 ;; (search-for-edges (_type_ collide-edge-hold-list) none 9)
|
|
(collide-edge-work-method-10 () none) ;; 10 ;; (debug-draw-edges (_type_) object 10)
|
|
(collide-edge-work-method-11 () none) ;; 11 ;; (debug-draw-tris (_type_) none 11)
|
|
(collide-edge-work-method-12 () none) ;; 12 ;; (debug-draw-sphere (_type_) none 12)
|
|
(collide-edge-work-method-13 () none) ;; 13 ;; (find-adjacent-edge (_type_ collide-edge-hold-item edge-grab-info) none 13)
|
|
(collide-edge-work-method-14 () none) ;; 14 ;; (compute-center-point! (_type_ collide-edge-edge vector) float 14)
|
|
(collide-edge-work-method-15 () none) ;; 15 ;; (get-best-hand-point (_type_ vector vector int) float 15)
|
|
(collide-edge-work-method-16 () none) ;; 16 ;; (find-grabbable-edges (_type_) none 16)
|
|
(collide-edge-work-method-17 () none) ;; 17 ;; (find-grabbable-tris (_type_) none 17)
|
|
(collide-edge-work-method-18 () none) ;; 18 ;; (should-add-to-list? (_type_ collide-edge-hold-item collide-edge-edge) symbol 18)
|
|
(collide-edge-work-method-19 () none) ;; 19 ;; (find-best-grab! (_type_ collide-edge-hold-list edge-grab-info) symbol 19)
|
|
(collide-edge-work-method-20 () none) ;; 20 ;; (check-grab-for-collisions (_type_ collide-edge-hold-item edge-grab-info) symbol 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *collide-edge-spec* object) ;; collide-edge-spec
|
|
;; (define-extern *collide-edge-work* object) ;; collide-edge-work
|
|
;; (define-extern *edge-grab-info* object) ;; edge-grab-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hfrag-work ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *hfrag-work* object)
|
|
;; (define-extern *hfrag-vu1-constants-base* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; euler-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype euler-angles (vector)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern EulSafe array) ;; (array int32)
|
|
;; (define-extern EulNext array) ;; (array int32)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mhcity-obs2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mhcity-puffer (process-focusable)
|
|
((state-time uint64 :offset-assert 192)
|
|
(period uint64 :offset-assert 216)
|
|
(duration uint64 :offset-assert 224)
|
|
(offset uint64 :offset-assert 232)
|
|
(is-jump? basic :offset-assert 240)
|
|
(jump-y float :offset-assert 244)
|
|
(jump-z float :offset-assert 248)
|
|
(traj trajectory :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x128
|
|
:flag-assert #x2300b00128
|
|
(:methods
|
|
(mhcity-puffer-method-32 () none) ;; 32
|
|
(mhcity-puffer-method-33 () none) ;; 33
|
|
(mhcity-puffer-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
puffer-active-base-state ;; 31
|
|
blowing-prep ;; 30
|
|
blowing ;; 29
|
|
active ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype puffer-init-by-other-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(orient quaternion :inline :offset-assert 16)
|
|
(scale float :offset-assert 32)
|
|
(period uint64 :offset-assert 40)
|
|
(duration uint64 :offset-assert 48)
|
|
(offset uint64 :offset-assert 56)
|
|
(jump-y float :offset-assert 64)
|
|
(jump-z float :offset-assert 68)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-puffer-large (mhcity-puffer)
|
|
()
|
|
:method-count-assert 35
|
|
:size-assert #x128
|
|
:flag-assert #x2300b00128
|
|
(:state-methods
|
|
blowing-prep ;; 30
|
|
blowing ;; 29
|
|
active ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern puffer-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasgun-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-wascity-gungame (task-manager)
|
|
((wascity-gungame-entity basic :offset-assert 236)
|
|
(check-timer uint64 :offset-assert 244)
|
|
(actor-group uint32 :offset-assert 252)
|
|
(actor-group-count int32 :offset-assert 256)
|
|
(cur-group int8 :offset-assert 260)
|
|
(halfway-up? basic :offset-assert 264)
|
|
(nskeet int16 :offset-assert 268)
|
|
(hopped-out uint64 :offset-assert 276)
|
|
(miss-count int16 :offset-assert 284)
|
|
(last-miss-count int16 :offset-assert 286)
|
|
(launch-time uint64 :offset-assert 292)
|
|
(win-time uint64 :offset-assert 300)
|
|
(lose-time uint64 :offset-assert 308)
|
|
(last-hit-time uint64 :offset-assert 316)
|
|
(added-points-time uint64 :offset-assert 324)
|
|
(point-queue int16 :offset-assert 332)
|
|
(skeet-hit int16 :offset-assert 334)
|
|
(shot-count-at-last-hit int16 :offset-assert 336)
|
|
(bonus-mult int16 :offset-assert 338)
|
|
(numshots int16 :offset-assert 340)
|
|
(queue-time int32 :offset-assert 344)
|
|
(event-length uint64 :offset-assert 348)
|
|
(event-time uint64 :offset-assert 356)
|
|
(shot-timer uint64 :offset-assert 364)
|
|
(wct uint64 :offset-assert 372)
|
|
(wave int32 :offset-assert 380)
|
|
(event int32 :offset-assert 384)
|
|
(goal-amount int8 :offset-assert 388)
|
|
(score int32 :offset-assert 392)
|
|
(hud-score uint64 :offset-assert 396)
|
|
(hud-goal uint64 :offset-assert 404)
|
|
(hud-miss uint64 :offset-assert 412)
|
|
(hud-reticle uint64 :offset-assert 420)
|
|
(hud-active? basic :offset-assert 428)
|
|
(been-out-of-turret? basic :offset-assert 432)
|
|
(won? basic :offset-assert 436)
|
|
(lost? basic :offset-assert 440)
|
|
(game-score uint8 :offset-assert 444)
|
|
(task-gold uint16 :offset-assert 446)
|
|
(task-silver uint16 :offset-assert 448)
|
|
(task-bronze uint16 :offset-assert 450)
|
|
(score-bronze int32 :offset-assert 452)
|
|
(score-silver int32 :offset-assert 456)
|
|
(score-gold int32 :offset-assert 460)
|
|
(score-high int32 :offset-assert 464)
|
|
(sound-id uint32 :offset-assert 468)
|
|
)
|
|
:method-count-assert 42
|
|
:size-assert #x1dc
|
|
:flag-assert #x2a016001dc
|
|
(:methods
|
|
(task-manager-wascity-gungame-method-32 () none) ;; 32
|
|
(task-manager-wascity-gungame-method-33 () none) ;; 33
|
|
(task-manager-wascity-gungame-method-34 () none) ;; 34
|
|
(task-manager-wascity-gungame-method-35 () none) ;; 35
|
|
(task-manager-wascity-gungame-method-36 () none) ;; 36
|
|
(task-manager-wascity-gungame-method-37 () none) ;; 37
|
|
(task-manager-wascity-gungame-method-38 () none) ;; 38
|
|
(task-manager-wascity-gungame-method-39 () none) ;; 39
|
|
(task-manager-wascity-gungame-method-40 () none) ;; 40
|
|
(task-manager-wascity-gungame-method-41 () none) ;; 41
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hip-skeet-event (structure)
|
|
((min-time uint32 :offset-assert 0)
|
|
(max-time uint32 :offset-assert 4)
|
|
(mode uint8 :offset-assert 8)
|
|
(angle float :offset-assert 12)
|
|
(speed float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *wasgun-speedmult* object)
|
|
;; (define-extern *skeet-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *skeet-b-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *skeet-c-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *skeet-data* array)
|
|
;; (define-extern *skeet-rigid-body-constants* object)
|
|
;; (define-extern wasgun-manager-shot-missed function)
|
|
;; (define-extern skeet-standard-event-handler function)
|
|
;; (define-extern *skeet-focus-pos* object)
|
|
;; (define-extern skeet-init-by-other function)
|
|
;; (define-extern spawn-skeet function)
|
|
;; (define-extern *skeet-offset-table* array)
|
|
;; (define-extern def-launch-circle function)
|
|
;; (define-extern spawn-skeet-enum function)
|
|
;; (define-extern wasgun-standard-event-handler function)
|
|
;; (define-extern *skeet-launcher-pos* object)
|
|
;; (define-extern *skeet-target-pos* object)
|
|
;; (define-extern print-and-spawn-skeet function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; transform-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype transform (structure)
|
|
((trans vector :inline :offset-assert 0)
|
|
(rot vector :inline :offset-assert 16)
|
|
(scale vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trs (basic)
|
|
((trans vector :inline :offset-assert 16)
|
|
(rot vector :inline :offset-assert 32)
|
|
(scale vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; particle-curves ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype particle-curve-settings (structure)
|
|
((color-start basic :offset-assert 0)
|
|
(alpha-start basic :offset-assert 4)
|
|
(scale-x-start basic :offset-assert 8)
|
|
(scale-y-start basic :offset-assert 12)
|
|
(r-scalar basic :offset-assert 16)
|
|
(g-scalar basic :offset-assert 20)
|
|
(b-scalar basic :offset-assert 24)
|
|
(a-scalar basic :offset-assert 28)
|
|
(scale-x-scalar basic :offset-assert 32)
|
|
(scale-y-scalar basic :offset-assert 36)
|
|
(lifetime-base uint64 :offset-assert 40)
|
|
(lifetime-offset uint64 :offset-assert 48)
|
|
(flags uint64 :offset-assert 56)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
;; (define-extern birth-func-curve function)
|
|
;; (define-extern live-func-curve function)
|
|
;; (define-extern *alpha-fast* curve2d-fast)
|
|
;; (define-extern *unity-fast* curve2d-fast)
|
|
;; (define-extern *ccro* curve-color-fast)
|
|
;; (define-extern *scale-curve* curve2d-fast)
|
|
;; (define-extern *scale-range* curve2d-fast)
|
|
;; (define-extern *part-function-curve-test-curve-settings* object)
|
|
;; (define-extern ptest function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; decomp-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype decomp-work (structure)
|
|
((buffer0 uint8 2048 :offset-assert 0) ;; guessed by decompiler
|
|
(buffer1 uint8 2048 :offset-assert 2048) ;; guessed by decompiler
|
|
(indices uint16 2048 :offset-assert 4096) ;; guessed by decompiler
|
|
(temp-indices uint16 2048 :offset-assert 8192) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3000
|
|
:flag-assert #x900003000
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factoryc-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *factoryc-alpha-texture-anim-array* texture-anim-array)
|
|
;; (define-extern set-facc-conveyor-speed! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bones ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *bone-calculation-list* object) ;; bone-calculation-list
|
|
;; (define-extern bone-list-init function) ;; (function none)
|
|
;; (define-extern bones-vu0-block object) ;; vu-function
|
|
;; (define-extern bones-set-sqwc function) ;; (function none)
|
|
;; (define-extern bones-reset-sqwc function) ;; (function none)
|
|
;; (define-extern bones-init function) ;; (function dma-buffer none)
|
|
;; (define-extern bones-mtx-calc function) ;; (function (inline-array pris-mtx) (inline-array joint) (inline-array bone) uint object none)
|
|
;; (define-extern bones-mtx-calc-execute function) ;; (function none)
|
|
;; (define-extern dump-qword function) ;; (function qword none)
|
|
;; (define-extern dump-mem function) ;; (function pointer int none)
|
|
;; (define-extern bones-debug function) ;; (function none)
|
|
;; (define-extern dump-bone-mem function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; editable-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype editable-region (basic)
|
|
((changed symbol :offset-assert 4) ;; guessed by decompiler
|
|
(locked symbol :offset-assert 8) ;; guessed by decompiler
|
|
(id uint64 :offset-assert 16)
|
|
(filter editable-filter :offset-assert 24) ;; guessed by decompiler
|
|
(tree symbol :offset-assert 28) ;; guessed by decompiler
|
|
(level string :offset-assert 32) ;; guessed by decompiler
|
|
(on-enter string :offset-assert 36) ;; guessed by decompiler
|
|
(on-inside string :offset-assert 40) ;; guessed by decompiler
|
|
(on-exit string :offset-assert 44) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x30
|
|
:flag-assert #xd00000030
|
|
;; field on-enter uses ~A with a signed load. field on-inside uses ~A with a signed load. field on-exit uses ~A with a signed load.
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(editable-region-method-9 () none) ;; 9 ;; (editable-region-method-9 (_type_ editable-array int int) symbol 9)
|
|
(editable-region-method-10 () none) ;; 10 ;; (editable-region-method-10 (_type_ int) symbol 10)
|
|
(editable-region-method-11 () none) ;; 11 ;; (editable-region-method-11 (_type_ vector int) none 11)
|
|
(editable-region-method-12 () none) ;; 12 ;; (editable-region-method-12 (_type_) editable-filter 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable (basic)
|
|
((flags editable-flag :offset-assert 4)
|
|
(name string :offset-assert 8) ;; guessed by decompiler
|
|
(id uint32 :offset-assert 12)
|
|
(region editable-region :offset-assert 16) ;; guessed by decompiler
|
|
(owner pair :offset-assert 20) ;; guessed by decompiler
|
|
(prefix basic :offset-assert 24)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x1c
|
|
:flag-assert #x240000001c
|
|
(:methods
|
|
(editable-method-9 () none) ;; 9 ;; (get-color (_type_ int) rgba 9)
|
|
(editable-method-10 () none) ;; 10 ;; (editable-method-10 (_type_) none 10)
|
|
(editable-method-11 () none) ;; 11 ;; (editable-method-11 (_type_ vector) symbol 11)
|
|
(editable-method-12 () none) ;; 12 ;; (select-editable! (_type_ symbol) none 12)
|
|
(editable-method-13 () none) ;; 13 ;; (edit-get-distance (_type_ vector) float 13)
|
|
(editable-method-14 () none) ;; 14 ;; (edit-get-trans (_type_) vector 14)
|
|
(editable-method-15 () none) ;; 15 ;; (editable-method-15 (_type_ vector int) none 15)
|
|
(editable-method-16 () none) ;; 16 ;; (edit-coord! (_type_ vector editable-flag) none 16)
|
|
(editable-method-17 () none) ;; 17 ;; (editable-method-17 (_type_ vector) none 17)
|
|
(editable-method-18 () none) ;; 18 ;; (editable-method-18 (_type_ vector matrix) none 18)
|
|
(editable-method-19 () none) ;; 19 ;; (editable-method-19 (_type_ vector) none 19)
|
|
(editable-method-20 () none) ;; 20 ;; (editable-method-20 (_type_ vector vector vector vector) none 20)
|
|
(editable-method-21 () none) ;; 21 ;; (editable-method-21 (_type_ editable-region) none 21)
|
|
(editable-method-22 () none) ;; 22 ;; (editable-method-22 (_type_ editable-array int int) symbol 22)
|
|
(editable-method-23 () none) ;; 23 ;; (editable-method-23 (_type_) symbol 23)
|
|
(editable-method-24 () none) ;; 24 ;; (editable-method-24 (_type_) none 24)
|
|
(editable-method-25 () none) ;; 25 ;; (editable-method-25 (_type_ editable-array) none 25)
|
|
(editable-method-26 () none) ;; 26 ;; (editable-method-26 (_type_ editable editable-array) none 26)
|
|
(editable-method-27 () none) ;; 27 ;; (editable-method-27 (_type_ editable-array) editable 27)
|
|
(editable-method-28 () none) ;; 28 ;; (editable-method-28 (_type_ editable-filter) none 28)
|
|
(editable-method-29 () none) ;; 29 ;; (editable-method-29 (_type_ editable-filter) symbol 29)
|
|
(editable-method-30 () none) ;; 30
|
|
(editable-method-31 () none) ;; 31
|
|
(editable-method-32 () none) ;; 32
|
|
(editable-method-33 () none) ;; 33
|
|
(editable-method-34 () none) ;; 34
|
|
(editable-method-35 () none) ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-array (basic)
|
|
((allocated-length int32 :offset-assert 4)
|
|
(length int32 :offset-assert 8)
|
|
(region editable-region :offset-assert 12) ;; guessed by decompiler
|
|
(backup-region editable-region :offset-assert 16) ;; guessed by decompiler
|
|
(region-lock? symbol :offset-assert 20) ;; guessed by decompiler
|
|
(move-lock? symbol :offset-assert 24) ;; guessed by decompiler
|
|
(move-speed float :offset-assert 28)
|
|
(selection (array editable) :offset-assert 32) ;; guessed by decompiler
|
|
(filter editable-filter 2 :offset-assert 36) ;; guessed by decompiler
|
|
(target editable :offset-assert 44) ;; guessed by decompiler
|
|
(target-mode editable-command :offset-assert 48) ;; guessed by decompiler
|
|
(target-command editable-command :offset-assert 52) ;; guessed by decompiler
|
|
(target-message string :offset-assert 56) ;; guessed by decompiler
|
|
(edit-plane editable-plane :offset-assert 60) ;; guessed by decompiler
|
|
(edit-plane-center vector :inline :offset-assert 64)
|
|
(edit-plane-normal vector :inline :offset-assert 80)
|
|
(level-offset vector :inline :offset-assert 96)
|
|
(level-info-id uint32 :offset-assert 112)
|
|
(level uint32 :offset-assert 116) ;; guessed by decompiler
|
|
(edit-param0 float :offset-assert 120)
|
|
(data editable :dynamic :offset-assert 124) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x7c
|
|
:flag-assert #x140000007c
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(editable-array-method-9 () none) ;; 9 ;; (editable-array-method-9 (_type_ editable-command mouse-info) symbol 9)
|
|
(editable-array-method-10 () none) ;; 10 ;; (editable-array-method-10 (_type_ vector int) editable 10)
|
|
(editable-array-method-11 () none) ;; 11 ;; (editable-array-method-11 (_type_) int 11)
|
|
(editable-array-method-12 () none) ;; 12 ;; (editable-array-method-12 (_type_ editable-array) none 12)
|
|
(editable-array-method-13 () none) ;; 13 ;; (editable-array-method-13 (_type_ editable-command editable-command string) none 13)
|
|
(editable-array-method-14 () none) ;; 14 ;; (editable-array-method-14 (_type_ (function editable editable-region symbol) editable-region) (array editable) 14)
|
|
(editable-array-method-15 () none) ;; 15 ;; (editable-array-method-15 (_type_ editable) none 15)
|
|
(editable-array-method-16 () none) ;; 16 ;; (editable-array-method-16 (_type_) none 16)
|
|
(editable-array-method-17 () none) ;; 17 ;; (editable-array-method-17 (_type_ vector vector) vector 17)
|
|
(editable-array-method-18 () none) ;; 18
|
|
(editable-array-method-19 () none) ;; 19
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-point (editable)
|
|
((flags editable-flag :offset-assert 0)
|
|
(name string :offset-assert 4) ;; guessed by decompiler
|
|
(id uint32 :offset-assert 8)
|
|
(region editable-region :offset-assert 12) ;; guessed by decompiler
|
|
(owner pair :offset-assert 16) ;; guessed by decompiler
|
|
(prefix basic :offset-assert 20)
|
|
(radius meters :offset-assert 24) ;; float
|
|
(trans vector :inline :offset-assert 28)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x30
|
|
:flag-assert #x2400000030
|
|
(:methods
|
|
;; (new (symbol type vector editable-region) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-sphere (editable-point)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x30
|
|
:flag-assert #x2400000030
|
|
(:methods
|
|
;; (new (symbol type vector float editable-region) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-sample (editable-point)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x30
|
|
:flag-assert #x2400000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-light (editable-sphere)
|
|
((direction vector :inline :offset-assert 44)
|
|
(color vector :inline :offset-assert 60)
|
|
(decay-start float :offset-assert 76)
|
|
(ambient-point-ratio float :offset-assert 80)
|
|
(brightness float :offset-assert 84)
|
|
(shadow uint32 :offset-assert 44)
|
|
(shadows UNKNOWN 5 :offset-assert 88)
|
|
(shadow-ambi float :offset-assert 88)
|
|
(shadow-dir0 float :offset-assert 92)
|
|
(shadow-dir1 float :offset-assert 96)
|
|
(shadow-dir2 float :offset-assert 100)
|
|
(shadow-dir3 float :offset-assert 104)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x70
|
|
:flag-assert #x2400000070
|
|
(:methods
|
|
;; (new (symbol type vector float editable-region) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-entity (editable-point)
|
|
((angles euler-angles :inline :offset-assert 44)
|
|
(idx int32 :offset-assert 60)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x44
|
|
:flag-assert #x2500000044
|
|
(:methods
|
|
(editable-entity-method-36 () none) ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-face (editable)
|
|
((flags editable-flag :offset-assert 0)
|
|
(name string :offset-assert 4) ;; guessed by decompiler
|
|
(id uint32 :offset-assert 8)
|
|
(region editable-region :offset-assert 12) ;; guessed by decompiler
|
|
(owner pair :offset-assert 16) ;; guessed by decompiler
|
|
(prefix basic :offset-assert 20)
|
|
(length int32 :offset-assert 24)
|
|
(normal vector :inline :offset-assert 28)
|
|
(center vector :inline :offset-assert 44)
|
|
(vertex editable-point 6 :offset-assert 60) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x58
|
|
:flag-assert #x2600000058
|
|
(:methods
|
|
;; (new (symbol type editable-region) _type_ 0)
|
|
(editable-face-method-36 () none) ;; 36
|
|
(editable-face-method-37 () none) ;; 37
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-plane (editable)
|
|
((flags editable-flag :offset-assert 0)
|
|
(name string :offset-assert 4) ;; guessed by decompiler
|
|
(id uint32 :offset-assert 8)
|
|
(region editable-region :offset-assert 12) ;; guessed by decompiler
|
|
(owner pair :offset-assert 16) ;; guessed by decompiler
|
|
(prefix basic :offset-assert 20)
|
|
(length int32 :offset-assert 24)
|
|
(radius meters :offset-assert 28) ;; float
|
|
(vertex editable-point 2 :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x2c
|
|
:flag-assert #x260000002c
|
|
(:methods
|
|
;; (new (symbol type editable-region) _type_ 0)
|
|
(editable-plane-method-36 () none) ;; 36
|
|
(editable-plane-method-37 () none) ;; 37
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-player (process-drawable)
|
|
((current editable-array :offset-assert 200) ;; guessed by decompiler
|
|
(current-command uint32 :offset-assert 204)
|
|
(select-command function :offset-assert 208) ;; guessed by decompiler
|
|
(drag-command uint32 :offset-assert 212)
|
|
(extra-command function :offset-assert 216) ;; guessed by decompiler
|
|
(left-handed basic :offset-assert 220)
|
|
(light-names basic :offset-assert 224)
|
|
(external-cam-mode symbol :offset-assert 228) ;; guessed by decompiler
|
|
(command editable-command 6 :offset-assert 232) ;; guessed by decompiler
|
|
(close-menu-time uint64 :offset-assert 256) ;; time-frame
|
|
(mouse-pos vector :inline :offset-assert 272)
|
|
(mouse-end vector :inline :offset-assert 288)
|
|
(manipulator manipulator :inline :offset-assert 304)
|
|
(mouse-box UNKNOWN 2 :offset-assert 480)
|
|
(mouse-hit vector :inline :offset-assert 512)
|
|
(mouse-normal vector :inline :offset-assert 528)
|
|
(float-variable float :offset-assert 544)
|
|
(float-step float :offset-assert 548)
|
|
(float-max float :offset-assert 552)
|
|
(float-min float :offset-assert 556)
|
|
(float-id uint32 :offset-assert 560)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x234
|
|
:flag-assert #x1801c00234
|
|
(:methods
|
|
(editable-player-method-20 () none) ;; 20 ;; (idle () _type_ :state 20)
|
|
(editable-player-method-21 () none) ;; 21 ;; (editable-player-method-21 (_type_) none 21)
|
|
(editable-player-method-22 () none) ;; 22
|
|
(editable-player-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype editable-work (basic)
|
|
((num-found int16 :offset-assert 4)
|
|
(last-found int16 :offset-assert 6)
|
|
(last-x float :offset-assert 8)
|
|
(last-y float :offset-assert 12)
|
|
(hide basic :offset-assert 16)
|
|
(found editable 256 :offset-assert 20) ;; guessed by decompiler
|
|
(dists uint32 256 :offset-assert 1044) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x814
|
|
:flag-assert #x900000814
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *editable-temp-id* object) ;; int
|
|
;; (define-extern *editable-default-name* object)
|
|
;; (define-extern editable-command->string function) ;; (function editable-command string)
|
|
;; (define-extern editable-filter->string function) ;; (function editable-filter basic string)
|
|
;; (define-extern *editable-work* object) ;; editable-work
|
|
;; (define-extern *editable* object) ;; (pointer editable-player)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kg-hopper ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype kg-hopper (nav-enemy)
|
|
((speed-y float :offset-assert 620)
|
|
(accel-y float :offset-assert 624)
|
|
(next-jump-time int32 :offset-assert 628)
|
|
(path-intro basic :offset-assert 632)
|
|
(can-go-knocked? basic :offset-assert 636)
|
|
(land-anim-index int32 :offset-assert 640)
|
|
(step-num int32 :offset-assert 644)
|
|
(best-point vector :inline :offset-assert 656)
|
|
(best-score float :offset-assert 672)
|
|
(origin vector :inline :offset-assert 688)
|
|
(direction vector :inline :offset-assert 704)
|
|
(jump-dist float :offset-assert 720)
|
|
(side float :offset-assert 724)
|
|
(jump-start-anim uint32 :offset-assert 728)
|
|
(jump-air-anim uint32 :offset-assert 732)
|
|
(jump-land-anim uint32 :offset-assert 736)
|
|
(jump-height-min float :offset-assert 740)
|
|
(jump-anim-start-frame float :offset-assert 744)
|
|
(minimap connection-minimap :offset-assert 748)
|
|
)
|
|
:method-count-assert 194
|
|
:size-assert #x2f0
|
|
:flag-assert #xc2027002f0
|
|
(:methods
|
|
(kg-hopper-method-191 () none) ;; 191
|
|
(kg-hopper-method-192 () none) ;; 192
|
|
(kg-hopper-method-193 () none) ;; 193
|
|
)
|
|
(:state-methods
|
|
explode ;; 190
|
|
hostile ;; 38
|
|
jump ;; 44
|
|
stare ;; 37
|
|
active ;; 34
|
|
notice ;; 35
|
|
ambush ;; 47
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-hopper-anim-info (structure)
|
|
((hit-anim-index int32 :offset-assert 0)
|
|
(land-anim-index int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-hopper-global-info (basic)
|
|
((prev-yellow-hit int8 :offset-assert 4)
|
|
(prev-blue-hit int8 :offset-assert 5)
|
|
(yellow-hit-anim UNKNOWN 3 :offset-assert 8)
|
|
(blue-hit-anim UNKNOWN 3 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *kg-hopper-debris-params* debris-static-params)
|
|
;; (define-extern *kg-hopper-global-info* kg-hopper-global-info)
|
|
;; (define-extern *kg-hopper-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern *kg-hopper-next-jump-time* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; geometry-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype curve (structure)
|
|
((cverts (inline-array vector) :offset-assert 0) ;; guessed by decompiler
|
|
(num-cverts int32 :offset-assert 4)
|
|
(knots (pointer float) :offset-assert 8) ;; guessed by decompiler
|
|
(num-knots int32 :offset-assert 12)
|
|
(length float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype line-intersection-val (structure)
|
|
((tt0 float :offset-assert 0)
|
|
(tt1 float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype border-plane (basic)
|
|
((name symbol :offset-assert 4) ;; guessed by decompiler
|
|
(action basic :offset-assert 8)
|
|
(slot int8 :offset-assert 12)
|
|
(trans vector :inline :offset-assert 16)
|
|
(normal vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x30
|
|
:flag-assert #xb00000030
|
|
(:methods
|
|
(border-plane-method-9 () none) ;; 9 ;; (debug-draw (_type_) int 9)
|
|
(border-plane-method-10 () none) ;; 10 ;; (point-past-plane? (_type_ vector) symbol 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lissajous (structure)
|
|
((x-mag float :offset-assert 0)
|
|
(y-mag float :offset-assert 4)
|
|
(theta float :offset-assert 8)
|
|
(wx float :offset-assert 12)
|
|
(wy float :offset-assert 16)
|
|
(period-shift float :offset-assert 20)
|
|
(theta-rate float :offset-assert 24)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x1c
|
|
:flag-assert #xa0000001c
|
|
(:methods
|
|
(lissajous-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lissajous-interp (structure)
|
|
((current lissajous :inline :offset-assert 0)
|
|
(dest lissajous :inline :offset-assert 28)
|
|
(rate lissajous :inline :offset-assert 56)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x54
|
|
:flag-assert #xb00000054
|
|
(:methods
|
|
(lissajous-interp-method-9 () none) ;; 9
|
|
(lissajous-interp-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasstada-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype spectator-info (structure)
|
|
((flags int32 :offset-assert 0)
|
|
(textures basic :offset-assert 4)
|
|
(y-pos float :offset-assert 8)
|
|
(delta-y float :offset-assert 12)
|
|
(angle float :offset-assert 16)
|
|
(hola-time uint64 :offset-assert 24)
|
|
(offset uint32 :offset-assert 32)
|
|
(speed uint32 :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
;; field textures uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wasstada-crowd (process-drawable)
|
|
((mat matrix :inline :offset-assert 208)
|
|
(spectators UNKNOWN 15 :offset-assert 272)
|
|
(hola float :offset-assert 992)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x3e4
|
|
:flag-assert #x15037003e4
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *range-color-lava-geyser-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-lava-geyser-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-lava-geyser-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-lava-geyser-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-lava-geyser-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-lava-geyser-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-lava-geyser-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-lava-geyser-flame* curve2d-fast)
|
|
;; (define-extern *curve-scale-lava-geyser-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-scale-lava-geyser-flame-y* curve2d-fast)
|
|
;; (define-extern *part-wasstada-lava-geyser-flame-curve-settings* object)
|
|
;; (define-extern *range-color-wasstada-crucible-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-wasstada-crucible-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-wasstada-crucible-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-wasstada-crucible-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-wasstada-crucible-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-wasstada-crucible-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-wasstada-crucible-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-wasstada-crucible-flame* curve2d-fast)
|
|
;; (define-extern *curve-wasstada-crucible-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-wasstada-crucible-flame-y* curve2d-fast)
|
|
;; (define-extern *part-wasstada-crucible-flame-curve-settings* object)
|
|
;; (define-extern *range-color-wasstada-bowl-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-wasstada-bowl-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-wasstada-bowl-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-wasstada-bowl-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-wasstada-bowl-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-wasstada-bowl-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-wasstada-bowl-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-wasstada-bowl-flame* curve2d-fast)
|
|
;; (define-extern *curve-wasstada-bowl-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-wasstada-bowl-flame-y* curve2d-fast)
|
|
;; (define-extern *part-wasstada-bowl-flame-curve-settings* object)
|
|
;; (define-extern part-wasstada-bird1-path function)
|
|
;; (define-extern part-wasstada-bird2-path function)
|
|
;; (define-extern part-wasstada-bird3-path function)
|
|
;; (define-extern part-wasstada-bird4-path function)
|
|
;; (define-extern part-wasstada-bird5-path function)
|
|
;; (define-extern *crowd-dudes-position* array)
|
|
;; (define-extern *crowd-dudes-textures* array)
|
|
;; (define-extern crowd-dude-func function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; neo-wasp-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; profile-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype profile-segment (structure)
|
|
((name symbol :offset-assert 0) ;; guessed by decompiler
|
|
(start-time int16 :offset-assert 4)
|
|
(end-time int16 :offset-assert 6)
|
|
(count uint8 :offset-assert 8)
|
|
(vu-count uint8 :offset-assert 9)
|
|
(depth uint16 :offset-assert 10)
|
|
(color rgba :offset-assert 12) ;; guessed by decompiler
|
|
(code-time uint16 :offset-assert 4)
|
|
(vu-time uint16 :offset-assert 6)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype profile-collapse (structure)
|
|
((count int32 :offset-assert 0)
|
|
(data profile-segment 48 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x304
|
|
:flag-assert #x900000304
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype profile-segment-array (basic)
|
|
((count int16 :offset-assert 4)
|
|
(depth int8 :offset-assert 6)
|
|
(max-depth int8 :offset-assert 7)
|
|
(base-time int16 :offset-assert 8)
|
|
(segment profile-segment 9 :offset-assert 12) ;; guessed by decompiler
|
|
(data profile-segment 1024 :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x4030
|
|
:flag-assert #xd00004030
|
|
(:methods
|
|
(profile-segment-array-method-9 () none) ;; 9 ;; (get-total-time (_type_) int 9)
|
|
(profile-segment-array-method-10 () none) ;; 10 ;; (start-frame! (_type_) none 10)
|
|
(profile-segment-array-method-11 () none) ;; 11 ;; (start-segment! (_type_ symbol rgba) none 11)
|
|
(profile-segment-array-method-12 () none) ;; 12 ;; (end-segment! (_type_) none 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype profile-array (structure)
|
|
((data profile-segment-array 2 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x8
|
|
:flag-assert #xc00000008
|
|
(:methods
|
|
(profile-array-method-9 () none) ;; 9 ;; (setup-categories! (_type_) none 9)
|
|
(profile-array-method-10 () none) ;; 10 ;; (draw-bars! (_type_ dma-buffer int) none 10)
|
|
(profile-array-method-11 () none) ;; 11 ;; (draw-text! (_type_) none 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype profile-spec (structure)
|
|
((name basic :offset-assert 0)
|
|
(color uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *profile-gap-color* object) ;; rgba
|
|
;; (define-extern *profile-all-color* object) ;; rgba
|
|
;; (define-extern *profile-blit-color* object) ;; rgba
|
|
;; (define-extern *profile-sky-color* object) ;; rgba
|
|
;; (define-extern *profile-ocean-color* object) ;; rgba
|
|
;; (define-extern *profile-hfrag-color* object)
|
|
;; (define-extern *profile-tfrag-color* object) ;; rgba
|
|
;; (define-extern *profile-texture-color* object) ;; rgba
|
|
;; (define-extern *profile-tie-color* object)
|
|
;; (define-extern *profile-generic-color* object)
|
|
;; (define-extern *profile-merc-color* object) ;; rgba
|
|
;; (define-extern *profile-shrubbery-color* object)
|
|
;; (define-extern *profile-particle-color* object)
|
|
;; (define-extern *profile-debug-color* object) ;; rgba
|
|
;; (define-extern *profile-other-color* object)
|
|
;; (define-extern *profile-joints-color* object) ;; rgba
|
|
;; (define-extern *profile-draw-hook-color* object) ;; rgba
|
|
;; (define-extern *profile-background-color* object) ;; rgba
|
|
;; (define-extern *profile-foreground-color* object) ;; rgba
|
|
;; (define-extern *profile-bones-color* object) ;; rgba
|
|
;; (define-extern *profile-actors-color* object) ;; rgba
|
|
;; (define-extern *profile-collide-color* object) ;; rgba
|
|
;; (define-extern *profile-nav-color* object) ;; rgba
|
|
;; (define-extern *profile-camera-color* object) ;; rgba
|
|
;; (define-extern *profile-gs-sync-color* object)
|
|
;; (define-extern *profile-array* object) ;; profile-array
|
|
;; (define-extern *profile-collapse* object) ;; profile-collapse
|
|
;; (define-extern *profile-interrupt-segment* object) ;; profile-segment-array
|
|
;; (define-extern *profile-interrupt-start* object) ;; symbol
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flut-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flut-info (basic)
|
|
((entity basic :offset-assert 4)
|
|
(flut-trans vector :inline :offset-assert 16)
|
|
(flut-quat vector :inline :offset-assert 32)
|
|
(flut-scale vector :inline :offset-assert 48)
|
|
(prev-quat quaternion :inline :offset-assert 64)
|
|
(stick-lock basic :offset-assert 80)
|
|
(flap-sound-id uint32 :offset-assert 84)
|
|
(mode-sound-bank connection :offset-assert 88)
|
|
(mode basic :offset-assert 92)
|
|
(color-index int32 :offset-assert 96)
|
|
(as-daxter? basic :offset-assert 100)
|
|
(art-group-backup basic :offset-assert 104)
|
|
(flut-start-time uint64 :offset-assert 112)
|
|
(wild-turn-time uint64 :offset-assert 120)
|
|
(wild-turn-rate deg :offset-assert 128)
|
|
(attack-id uint32 :offset-assert 132)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x88
|
|
:flag-assert #x900000088
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flut (process-focusable)
|
|
((extra-trans vector :inline :offset-assert 208)
|
|
(condition int32 :offset-assert 224)
|
|
(shadow-backup basic :offset-assert 228)
|
|
(rider uint64 :offset-assert 232)
|
|
(nav-sphere-handle uint64 :offset-assert 240)
|
|
(probe-time uint64 :offset-assert 248)
|
|
(count-lock basic :offset-assert 256)
|
|
(flags uint64 :offset-assert 264)
|
|
(mode basic :offset-assert 272)
|
|
(color-index int32 :offset-assert 276)
|
|
(minimap connection-minimap :offset-assert 280)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x11c
|
|
:flag-assert #x2300a0011c
|
|
(:methods
|
|
(flut-method-28 () none) ;; 28
|
|
(flut-method-29 () none) ;; 29
|
|
(flut-method-30 () none) ;; 30
|
|
(flut-method-31 () none) ;; 31
|
|
(flut-method-32 () none) ;; 32
|
|
(flut-method-33 () none) ;; 33
|
|
(flut-method-34 () none) ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; light-trails ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern compute-trail-scaled-t function)
|
|
;; (define-extern *dist-cache-array* object)
|
|
;; (define-extern *total-length* object)
|
|
;; (define-extern light-trail-tracker-common-post function)
|
|
;; (define-extern estimate-light-trail-mem-usage function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; trigonometry-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; transformq-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype transformq (transform)
|
|
((quat quaternion :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trsq (trs)
|
|
((quat quaternion :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trsqv (trsq)
|
|
((pause-adjust-distance meters :offset-assert 4)
|
|
(nav-radius meters :offset-assert 8)
|
|
(transv vector :inline :offset-assert 64)
|
|
(rotv vector :inline :offset-assert 80)
|
|
(scalev vector :inline :offset-assert 96)
|
|
(dir-targ quaternion :inline :offset-assert 112)
|
|
(angle-change-time uint64 :offset-assert 128) ;; time-frame
|
|
(old-y-angle-diff float :offset-assert 136)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #x8c
|
|
:flag-assert #x1c0000008c
|
|
(:methods
|
|
(trsqv-method-9 () none) ;; 9 ;; (seek-toward-heading-vec! (_type_ vector float time-frame) quaternion 9)
|
|
(trsqv-method-10 () none) ;; 10 ;; (set-heading-vec! (_type_ vector) quaternion 10)
|
|
(trsqv-method-11 () none) ;; 11 ;; (seek-to-point-toward-point! (_type_ vector float time-frame) quaternion 11)
|
|
(trsqv-method-12 () none) ;; 12 ;; (point-toward-point! (_type_ vector) quaternion 12)
|
|
(trsqv-method-13 () none) ;; 13 ;; (seek-toward-yaw-angle! (_type_ float float time-frame) quaternion 13)
|
|
(trsqv-method-14 () none) ;; 14 ;; (set-yaw-angle-clear-roll-pitch! (_type_ float) quaternion 14)
|
|
(trsqv-method-15 () none) ;; 15 ;; (set-roll-to-grav! (_type_ float) quaternion 15)
|
|
(trsqv-method-16 () none) ;; 16 ;; (set-roll-to-grav-2! (_type_ float) quaternion 16)
|
|
(trsqv-method-17 () none) ;; 17 ;; (rotate-toward-orientation! (_type_ quaternion float float int int float) quaternion 17)
|
|
(trsqv-method-18 () none) ;; 18 ;; (set-quaternion! (_type_ quaternion) quaternion 18)
|
|
(trsqv-method-19 () none) ;; 19 ;; (set-heading-vec-clear-roll-pitch! (_type_ vector) quaternion 19)
|
|
(trsqv-method-20 () none) ;; 20 ;; (point-toward-point-clear-roll-pitch! (_type_ vector) quaternion 20)
|
|
(trsqv-method-21 () none) ;; 21 ;; (rot->dir-targ! (_type_) quaternion 21)
|
|
(trsqv-method-22 () none) ;; 22 ;; (y-angle (_type_) float 22)
|
|
(trsqv-method-23 () none) ;; 23 ;; (global-y-angle-to-point (_type_ vector) float 23)
|
|
(trsqv-method-24 () none) ;; 24 ;; (relative-y-angle-to-point (_type_ vector) float 24)
|
|
(trsqv-method-25 () none) ;; 25 ;; (roll-relative-to-gravity (_type_) float 25)
|
|
(trsqv-method-26 () none) ;; 26 ;; (set-and-limit-velocity (_type_ int vector float) trsqv 26)
|
|
(trsqv-method-27 () none) ;; 27 ;; (get-quaternion (_type_) quaternion 27)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctygenb-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lights-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vu-lights (structure)
|
|
((direction vector 3 :offset-assert 0) ;; guessed by decompiler
|
|
(color vector 3 :offset-assert 48) ;; guessed by decompiler
|
|
(ambient vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light (structure)
|
|
((direction vector :inline :offset-assert 0)
|
|
(color rgbaf :inline :offset-assert 16)
|
|
(extra vector :inline :offset-assert 32)
|
|
(level float :offset-assert 32)
|
|
(luminance float :offset-assert 40)
|
|
(priority float :offset-assert 44)
|
|
(bytes uint8 4 :offset-assert 36) ;; guessed by decompiler
|
|
(mask uint16 :offset-assert 36)
|
|
(palette-index int8 :offset-assert 39)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
;; (deftype light-shadow-mask (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
#|
|
|
(deftype light-sphere (structure)
|
|
((name string :offset-assert 0) ;; guessed by decompiler
|
|
(bsphere vector :inline :offset-assert 16)
|
|
(direction vector :inline :offset-assert 32)
|
|
(color vector :inline :offset-assert 48)
|
|
(decay-start float :offset-assert 4)
|
|
(ambient-point-ratio float :offset-assert 8)
|
|
(brightness float :offset-assert 12)
|
|
(bytes uint8 4 :offset-assert 60) ;; guessed by decompiler
|
|
(mask uint16 :offset-assert 60)
|
|
(palette-index int8 :offset-assert 63)
|
|
(shadow uint32 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-hash-bucket (structure)
|
|
((index uint16 :offset-assert 0)
|
|
(count uint16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-hash (basic)
|
|
((num-lights uint16 :offset-assert 4)
|
|
(num-indices uint16 :offset-assert 6)
|
|
(num-buckets uint16 :offset-assert 8)
|
|
(bucket-step uint8 2 :offset-assert 10) ;; guessed by decompiler
|
|
(base-trans vector :inline :offset-assert 16)
|
|
(axis-scale vector :inline :offset-assert 32)
|
|
(dimension-array vector4w :inline :offset-assert 48)
|
|
(bucket-array (inline-array light-hash-bucket) :offset-assert 64) ;; guessed by decompiler
|
|
(index-array pointer :offset-assert 68) ;; guessed by decompiler
|
|
(light-sphere-array (inline-array light-sphere) :offset-assert 72) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-hash-work (structure)
|
|
((ones vector4w :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-group (structure)
|
|
((dir0 light :inline :offset-assert 0)
|
|
(dir1 light :inline :offset-assert 48)
|
|
(dir2 light :inline :offset-assert 96)
|
|
(ambi light :inline :offset-assert 144)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc0
|
|
:flag-assert #x9000000c0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *light-hash* object) ;; light-hash
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-merc-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype merc-matrix (structure)
|
|
((quad uint128 8 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 8 :offset-assert 0) ;; guessed by decompiler
|
|
(tag uint64 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-merc-tag (dma-packet)
|
|
((next-ptr uint32 :offset-assert 12)
|
|
(size uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-merc-ctrl (structure)
|
|
((tag generic-merc-tag :inline :offset-assert 0)
|
|
(lights vu-lights :inline :offset-assert 16)
|
|
(header merc-ctrl-header :inline :offset-assert 128)
|
|
(effect merc-effect :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x120
|
|
:flag-assert #x900000120
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-merc-ctrl-with-sfx (generic-merc-ctrl)
|
|
((sfx-data uint128 11 :offset-assert 288) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1d0
|
|
:flag-assert #x9000001d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-merc-input (structure)
|
|
((geo-tag generic-merc-tag :inline :offset-assert 0)
|
|
(geo-block uint8 1296 :offset-assert 16) ;; guessed by decompiler
|
|
(byte-header merc-byte-header :inline :offset-assert 16)
|
|
(matrix merc-matrix 9 :offset-assert 1312) ;; guessed by decompiler
|
|
(control generic-merc-ctrl-with-sfx :inline :offset-assert 2464)
|
|
(end-tag generic-merc-tag :inline :offset-assert 2928)
|
|
(shader adgif-shader :inline :offset-assert 2944)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xbd0
|
|
:flag-assert #x900000bd0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-merc-output (structure)
|
|
((info gsf-info :inline :offset-assert 0)
|
|
(header gsf-header :inline :offset-assert 16)
|
|
(index-kick-table uint16 80 :offset-assert 32) ;; guessed by decompiler
|
|
(index-table uint8 160 :offset-assert 32) ;; guessed by decompiler
|
|
(inverse-table uint8 256 :offset-assert 192) ;; guessed by decompiler
|
|
(vertex-table gsf-vertex 72 :offset-assert 448) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xac0
|
|
:flag-assert #x900000ac0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-merc-dcache (structure)
|
|
((output-a generic-merc-output :inline :offset-assert 0)
|
|
(output-b generic-merc-output :inline :offset-assert 2752)
|
|
(inv-table-1 uint8 544 :offset-assert 5504) ;; guessed by decompiler
|
|
(inv-table-7 uint8 544 :offset-assert 6048) ;; guessed by decompiler
|
|
(inv-safety uint8 16 :offset-assert 6592) ;; guessed by decompiler
|
|
(effect-data uint8 1584 :offset-assert 6608) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2000
|
|
:flag-assert #x900002000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gm-shadow (structure)
|
|
((perspective matrix :inline :offset-assert 0)
|
|
(isometric matrix :inline :offset-assert 64)
|
|
(inv-camera-rot matrix :inline :offset-assert 128)
|
|
(envmap-shader adgif-shader :inline :offset-assert 192)
|
|
(current-chain uint32 :offset-assert 272)
|
|
(next-chain uint32 :offset-assert 276)
|
|
(buf-index uint32 :offset-assert 280)
|
|
(fragment-count uint32 :offset-assert 284)
|
|
(write-limit int32 :offset-assert 288)
|
|
(indexed-input-base generic-merc-input :offset-assert 292)
|
|
(other-input-base generic-merc-input :offset-assert 296)
|
|
(indexed-output-base generic-merc-output :offset-assert 300)
|
|
(other-output-base generic-merc-output :offset-assert 304)
|
|
(p-input uint32 :offset-assert 308)
|
|
(gsf-buf generic-merc-dcache :offset-assert 312)
|
|
(p-fheader merc-fp-header :offset-assert 316)
|
|
(curr-chain basic :offset-assert 320)
|
|
(mercneric-convert basic :offset-assert 324)
|
|
(generic-prepare-dma-single basic :offset-assert 328)
|
|
(generic-prepare-dma-double basic :offset-assert 332)
|
|
(generic-light-proc basic :offset-assert 336)
|
|
(generic-envmap-proc basic :offset-assert 340)
|
|
(high-speed-reject basic :offset-assert 344)
|
|
(dummy-0 uint32 :offset-assert 348)
|
|
(hsr-xmult vector :inline :offset-assert 352)
|
|
(hsr-ymult vector :inline :offset-assert 368)
|
|
(warp-consts vector :inline :offset-assert 384)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x190
|
|
:flag-assert #x900000190
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-merc-work (structure)
|
|
((input-a generic-merc-input :inline :offset-assert 0)
|
|
(input-b generic-merc-input :inline :offset-assert 3024)
|
|
(ctrl generic-merc-ctrl-with-sfx :inline :offset-assert 6048)
|
|
(shadow gm-shadow :inline :offset-assert 6512)
|
|
(stack uint128 16 :offset-assert 6912) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c00
|
|
:flag-assert #x900001c00
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; texture-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype texture-id (uint32)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-pool-segment (structure)
|
|
((dest uint32 :offset-assert 0)
|
|
(size uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-pool (basic)
|
|
((top int32 :offset-assert 4)
|
|
(cur int32 :offset-assert 8)
|
|
(allocate-func (function texture-pool texture-page kheap int texture-page) :offset-assert 12) ;; guessed by decompiler
|
|
(font-palette int32 :offset-assert 16)
|
|
(segment texture-pool-segment 4 :offset-assert 20) ;; guessed by decompiler
|
|
(segment-near texture-pool-segment :inline :offset-assert 20)
|
|
(segment-common texture-pool-segment :inline :offset-assert 28)
|
|
(common-page texture-page 32 :offset-assert 52) ;; guessed by decompiler
|
|
(common-page-mask int32 :offset-assert 180)
|
|
(update-sprites-flag symbol :offset-assert 184) ;; guessed by decompiler
|
|
(update-flag symbol :offset-assert 188) ;; guessed by decompiler
|
|
(texture-enable-user uint64 :offset-assert 192) ;; texture-enable-mask
|
|
(texture-enable-user-menu uint64 :offset-assert 200) ;; texture-enable-mask
|
|
(ids uint32 128 :offset-assert 208) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x2d0
|
|
:flag-assert #x1a000002d0
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(texture-pool-method-9 () none) ;; 9 ;; (initialize! (_type_) _type_ 9)
|
|
(texture-pool-method-10 () none) ;; 10 ;; (print-usage (_type_) _type_ 10)
|
|
(texture-pool-method-11 () none) ;; 11 ;; (setup-font-texture (_type_) none 11)
|
|
(texture-pool-method-12 () none) ;; 12 ;; (allocate-defaults (_type_) none 12)
|
|
(texture-pool-method-13 () none) ;; 13 ;; (login-level-textures (_type_ level int (pointer texture-id)) none 13)
|
|
(texture-pool-method-14 () none) ;; 14 ;; (add-level-tpage-dma (_type_ level tpage-category bucket-id) none 14)
|
|
(texture-pool-method-15 () none) ;; 15 ;; (allocate-vram-words! (_type_ int) int 15)
|
|
(texture-pool-method-16 () none) ;; 16 ;; (allocate-segment (_type_ texture-pool-segment int) texture-pool-segment 16)
|
|
(texture-pool-method-17 () none) ;; 17 ;; (unload-page (_type_ texture-page) none 17)
|
|
(texture-pool-method-18 () none) ;; 18 ;; (get-common-page-slot-by-id (_type_ int) int 18)
|
|
(texture-pool-method-19 () none) ;; 19 ;; (update-warp-and-hud (_type_) none 19)
|
|
(texture-pool-method-20 () none) ;; 20 ;; (update-sprites (_type_) none 20)
|
|
(texture-pool-method-21 () none) ;; 21 ;; (mark-hud-warp-sprite-dirty (_type_) none 21)
|
|
(texture-pool-method-22 () none) ;; 22 ;; (lay-out-sprite-tex (_type_) none 22)
|
|
(texture-pool-method-23 () none) ;; 23 ;; (lay-out-hud-tex (_type_) none 23)
|
|
(texture-pool-method-24 () none) ;; 24 ;; (lay-out-warp-tex (_type_) none 24)
|
|
(texture-pool-method-25 () none) ;; 25 ;; (clear-ids (_type_) none 25)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-mask (structure)
|
|
((mask vector4w :inline :offset-assert 0)
|
|
(dist float :offset-assert 12)
|
|
(long uint64 2 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-masks (structure)
|
|
((data texture-mask 3 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-masks-array (inline-array-class)
|
|
((data texture-masks :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture (basic)
|
|
((w int16 :offset-assert 4)
|
|
(h int16 :offset-assert 6)
|
|
(num-mips uint8 :offset-assert 8)
|
|
(tex1-control uint8 :offset-assert 9)
|
|
(psm uint8 :offset-assert 10) ;; gs-psm
|
|
(mip-shift uint8 :offset-assert 11)
|
|
(clutpsm uint16 :offset-assert 12)
|
|
(dest uint16 7 :offset-assert 14) ;; guessed by decompiler
|
|
(clutdest uint16 :offset-assert 28)
|
|
(width uint8 7 :offset-assert 30) ;; guessed by decompiler
|
|
(name string :offset-assert 40) ;; guessed by decompiler
|
|
(size uint32 :offset-assert 44)
|
|
(uv-dist float :offset-assert 48)
|
|
(pad uint32 3 :offset-assert 52) ;; guessed by decompiler
|
|
(masks texture-masks :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-page-segment (structure)
|
|
((block-data pointer :offset-assert 0) ;; guessed by decompiler
|
|
(size uint32 :offset-assert 4)
|
|
(dest uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-page (basic)
|
|
((info file-info :offset-assert 4) ;; guessed by decompiler
|
|
(name string :offset-assert 8) ;; guessed by decompiler
|
|
(id uint32 :offset-assert 12)
|
|
(length int32 :offset-assert 16)
|
|
(mip0-size uint32 :offset-assert 20)
|
|
(size uint32 :offset-assert 24)
|
|
(segment texture-page-segment 3 :offset-assert 28) ;; guessed by decompiler
|
|
(dram-size uint32 :offset-assert 64)
|
|
(vram-size uint32 :offset-assert 68)
|
|
(pad uint32 14 :offset-assert 72) ;; guessed by decompiler
|
|
(data texture :dynamic :offset-assert 128) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x80
|
|
:flag-assert #xe00000080
|
|
(:methods
|
|
(texture-page-method-9 () none) ;; 9 ;; (remove-data-from-heap (_type_ kheap) _type_ 9)
|
|
(texture-page-method-10 () none) ;; 10 ;; (get-leftover-block-count (_type_ int int) int 10)
|
|
(texture-page-method-11 () none) ;; 11 ;; (relocate-dests! (_type_ int int) none 11)
|
|
(texture-page-method-12 () none) ;; 12 ;; (add-to-dma-buffer (_type_ dma-buffer tex-upload-mode) int 12)
|
|
(texture-page-method-13 () none) ;; 13 ;; (upload-now! (_type_ tex-upload-mode) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (deftype shader-ptr (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
#|
|
|
(deftype texture-link (structure)
|
|
((next shader-ptr :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-page-dir-entry (structure)
|
|
((length int16 :offset-assert 0)
|
|
(status uint16 :offset-assert 2)
|
|
(page texture-page :offset-assert 4) ;; guessed by decompiler
|
|
(link texture-link :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; (deftype texture-page-dir (basic)
|
|
;; ()
|
|
;; :flag-assert #xa00000014
|
|
;; )
|
|
|
|
#|
|
|
(deftype texture-relocate-later (basic)
|
|
((memcpy symbol :offset-assert 4) ;; guessed by decompiler
|
|
(dest uint32 :offset-assert 8)
|
|
(source uint32 :offset-assert 12)
|
|
(move uint32 :offset-assert 16)
|
|
(entry texture-page-dir-entry :offset-assert 20)
|
|
(page texture-page :offset-assert 24) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype adgif-shader (structure)
|
|
((quad qword 5 :offset-assert 0) ;; guessed by decompiler
|
|
(prims gs-reg64 10 :offset-assert 0) ;; guessed by decompiler
|
|
(reg-0 uint8 :offset-assert 8)
|
|
(reg-1 uint8 :offset-assert 24)
|
|
(reg-2 uint8 :offset-assert 40)
|
|
(reg-3 uint8 :offset-assert 56)
|
|
(reg-4 uint8 :offset-assert 72)
|
|
(tex0 uint64 :offset-assert 0) ;; gs-tex0
|
|
(tex1 uint64 :offset-assert 16) ;; gs-tex1
|
|
(miptbp1 uint64 :offset-assert 32) ;; gs-miptbp
|
|
(clamp uint64 :offset-assert 48) ;; gs-clamp
|
|
(clamp-reg uint64 :offset-assert 56) ;; gs-reg64
|
|
(alpha uint64 :offset-assert 64) ;; gs-alpha
|
|
(link-test link-test-flags :offset-assert 8) ;; guessed by decompiler
|
|
(texture-id texture-id :offset-assert 24) ;; guessed by decompiler
|
|
(next shader-ptr :offset-assert 40) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype adgif-shader-array (inline-array-class)
|
|
((data adgif-shader :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-base (structure)
|
|
((vram-page uint32 :offset-assert 0)
|
|
(vram-block uint32 :offset-assert 4)
|
|
(vram-word uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-page-translate-item (structure)
|
|
((bucket int32 :offset-assert 0) ;; bucket-id
|
|
(level-index uint32 :offset-assert 4)
|
|
(level-texture-page tpage-category-u32 :offset-assert 8) ;; guessed by decompiler
|
|
(texture-user texture-enable-mask-u32 :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *texture-masks* object) ;; texture-masks
|
|
;; (define-extern *texture-masks-array* object) ;; texture-masks-array
|
|
;; (define-extern texture-mip->segment function) ;; (function int int int)
|
|
;; (define-extern *texture-relocate-later* object) ;; texture-relocate-later
|
|
;; (define-extern *texture-page-dir* object) ;; texture-page-dir
|
|
;; (define-extern ct32-24-block-table array) ;; (array int32)
|
|
;; (define-extern mz32-24-block-table array) ;; (array int32)
|
|
;; (define-extern ct16-block-table array) ;; (array int32)
|
|
;; (define-extern ct16s-block-table array) ;; (array int32)
|
|
;; (define-extern mz16-block-table array) ;; (array int32)
|
|
;; (define-extern mz16s-block-table array) ;; (array int32)
|
|
;; (define-extern mt8-block-table array) ;; (array int32)
|
|
;; (define-extern mt4-block-table array) ;; (array int32)
|
|
;; (define-extern *texture-page-translate* array) ;; (array texture-page-translate-item)
|
|
;; (define-extern *eyes-texture-base* object) ;; texture-base
|
|
;; (define-extern *skull-gem-texture-base* object) ;; texture-base
|
|
;; (define-extern *ocean-texture-base* object) ;; texture-base
|
|
;; (define-extern *ocean-envmap-texture-base* object) ;; texture-base
|
|
;; (define-extern *grey-scale-base* object) ;; texture-base
|
|
;; (define-extern *map-texture-base* object) ;; texture-base
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bounding-box ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype liang-barsky-line-clip-params (structure)
|
|
((te float :offset-assert 0)
|
|
(tl float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern box-vector-enside? function) ;; (function bounding-box vector symbol)
|
|
;; (define-extern box-vector-inside? function) ;; (function bounding-box vector symbol)
|
|
;; (define-extern liang-barsky-line-clipt function) ;; (function liang-barsky-line-clip-params float float symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; matrix ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; matrix is already defined!
|
|
|
|
;; matrix3 is already defined!
|
|
|
|
;; (define-extern matrix-identity! function) ;; (function matrix matrix)
|
|
;; (define-extern *identity-matrix* object) ;; matrix
|
|
;; (define-extern *hermite-matrix* object) ;; matrix
|
|
;; (define-extern matrix+! function) ;; (function matrix matrix matrix matrix)
|
|
;; (define-extern matrix-! function) ;; (function matrix matrix matrix matrix)
|
|
;; (define-extern matrix*! function) ;; (function matrix matrix matrix matrix)
|
|
;; (define-extern matrixp*! function) ;; (function matrix matrix matrix matrix)
|
|
;; (define-extern vector-matrix*! function) ;; (function vector vector matrix vector)
|
|
;; (define-extern vector-norm-matrix*! function)
|
|
;; (define-extern vector-rotate*! function) ;; (function vector vector matrix vector)
|
|
;; (define-extern vector3s-matrix*! function) ;; (function vector3s vector3s matrix vector3s)
|
|
;; (define-extern vector3s-rotate*! function) ;; (function vector3s vector3s matrix vector3s)
|
|
;; (define-extern matrix-transpose! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix-inverse-of-rot-trans! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix-4x4-inverse! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix-translate! function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-translate+! function) ;; (function matrix matrix vector matrix)
|
|
;; (define-extern matrix-scale! function) ;; (function matrix vector matrix)
|
|
;; (define-extern scale-matrix! function) ;; (function matrix vector matrix matrix)
|
|
;; (define-extern matrix-inv-scale! function) ;; (function matrix vector matrix)
|
|
;; (define-extern column-scale-matrix! function) ;; (function matrix vector matrix matrix)
|
|
;; (define-extern matrix-rotate-x! function) ;; (function matrix float matrix)
|
|
;; (define-extern matrix-rotate-y! function) ;; (function matrix float matrix)
|
|
;; (define-extern matrix-rotate-z! function) ;; (function matrix float matrix)
|
|
;; (define-extern matrix-rotate-zyx! function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-rotate-xyz-2! function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-rotate-xyz! function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-rotate-zxy! function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-rotate-yxz! function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-rotate-yzx! function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-rotate-yxy! function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-rotate-yx! function) ;; (function matrix float float matrix)
|
|
;; (define-extern matrix-axis-sin-cos-vu! function) ;; (function matrix vector float float none)
|
|
;; (define-extern matrix-axis-sin-cos! function) ;; (function matrix vector float float matrix)
|
|
;; (define-extern matrix-axis-angle! function) ;; (function matrix vector float matrix)
|
|
;; (define-extern matrix-lerp! function) ;; (function matrix matrix matrix float matrix)
|
|
;; (define-extern matrix-3x3-determinant function) ;; (function matrix float)
|
|
;; (define-extern matrix3-determinant function) ;; (function matrix float)
|
|
;; (define-extern matrix-3x3-inverse! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix-3x3-inverse-transpose! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix3-inverse-transpose! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix-3x3-normalize! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix-4x4-determinant function) ;; (function matrix float)
|
|
;; (define-extern matrix-4x4-inverse-transpose! function) ;; (function matrix matrix matrix)
|
|
;; (define-extern matrix-y-angle function) ;; (function matrix float)
|
|
;; (define-extern matrix->trans function) ;; (function matrix vector vector)
|
|
;; (define-extern matrix<-trans function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix->scale function) ;; (function matrix vector vector)
|
|
;; (define-extern matrix<-scale function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix->quat function) ;; (function matrix quaternion quaternion)
|
|
;; (define-extern matrix<-quat function) ;; (function matrix quaternion matrix)
|
|
;; (define-extern matrix->transformq function) ;; (function transformq matrix transformq)
|
|
;; (define-extern matrix-mirror! function) ;; (function matrix vector vector matrix)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; matrix-compose ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern matrix-fur-compose function)
|
|
;; (define-extern matrix-fu-compose function)
|
|
;; (define-extern matrix-fr-compose function)
|
|
;; (define-extern matrix-ur-compose function)
|
|
;; (define-extern matrix-f-u-compose function)
|
|
;; (define-extern matrix-f-r-compose function)
|
|
;; (define-extern matrix-u-f-compose function)
|
|
;; (define-extern matrix-u-r-compose function)
|
|
;; (define-extern matrix-r-f-compose function)
|
|
;; (define-extern matrix-r-u-compose function)
|
|
;; (define-extern matrix-f-compose function)
|
|
;; (define-extern matrix-u-compose function)
|
|
;; (define-extern matrix-r-compose function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-hash-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collide-hash-scratch (structure)
|
|
((collidable-bits uint128 128 :offset-assert 0) ;; guessed by decompiler
|
|
(poly-bits uint64 2 :offset-assert 0) ;; guessed by decompiler
|
|
(id-bits uint32 512 :offset-assert 0) ;; guessed by decompiler
|
|
(tris uint32 :offset-assert 2048)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x804
|
|
:flag-assert #x900000804
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-hash-bucket (structure)
|
|
((index int16 :offset-assert 0)
|
|
(count int16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-hash-item (structure)
|
|
((id uint32 :offset-assert 0)
|
|
(collidable basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-hash-poly (structure)
|
|
((data uint8 4 :offset-assert 0) ;; guessed by decompiler
|
|
(vert-index0 uint8 :offset-assert 0)
|
|
(vert-index1 uint8 :offset-assert 1)
|
|
(vert-index2 uint8 :offset-assert 2)
|
|
(pat-index uint8 :offset-assert 3)
|
|
(word uint32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-hash-fragment-stats (structure)
|
|
((num-verts uint16 :offset-assert 0)
|
|
(num-polys uint8 :offset-assert 2)
|
|
(poly-count uint8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-hash-fragment (drawable)
|
|
((num-buckets uint16 :offset-assert 4)
|
|
(num-indices uint16 :offset-assert 6)
|
|
(pat-array uint32 :offset-assert 8)
|
|
(bucket-array uint32 :offset-assert 12)
|
|
(grid-step vector :inline :offset-assert 32)
|
|
(bbox bounding-box :inline :offset-assert 48)
|
|
(bbox4w bounding-box4w :inline :offset-assert 80)
|
|
(axis-scale vector :inline :offset-assert 64)
|
|
(avg-extents vector :inline :offset-assert 80)
|
|
(dimension-array uint32 4 :offset-assert 44) ;; guessed by decompiler
|
|
(stats collide-hash-fragment-stats :inline :offset-assert 60)
|
|
(num-verts uint16 :offset-assert 60)
|
|
(num-polys uint8 :offset-assert 62)
|
|
(poly-count uint8 :offset-assert 63)
|
|
(poly-array uint32 :offset-assert 76)
|
|
(vert-array uint32 :offset-assert 92)
|
|
(index-array uint32 :offset-assert 108)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x70
|
|
:flag-assert #x1100000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-hash-fragment-array (array)
|
|
((type type :offset-assert 0) ;; guessed by decompiler
|
|
(length int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
(content-type type :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-hash (drawable)
|
|
((num-ids uint16 :offset-assert 4)
|
|
(id-count uint16 :offset-assert 6)
|
|
(num-buckets uint32 :offset-assert 8)
|
|
(qwc-id-bits uint32 :offset-assert 12)
|
|
(grid-step vector :inline :offset-assert 16)
|
|
(bbox bounding-box :inline :offset-assert 32)
|
|
(bbox4w bounding-box4w :inline :offset-assert 64)
|
|
(axis-scale vector :inline :offset-assert 48)
|
|
(avg-extents vector :inline :offset-assert 64)
|
|
(bucket-array uint32 :offset-assert 44)
|
|
(item-array (inline-array collide-hash-item) :offset-assert 60) ;; guessed by decompiler
|
|
(dimension-array uint32 3 :offset-assert 76) ;; guessed by decompiler
|
|
(num-items uint32 :offset-assert 92)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x60
|
|
:flag-assert #x1100000060
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *collide-list-boxes* object) ;; object
|
|
;; (define-extern *collide-hash-fragments* object) ;; object
|
|
;; (define-extern *collide-hash-fragments-tfrag* object) ;; object
|
|
;; (define-extern *collide-hash-fragments-instance* object) ;; object
|
|
;; (define-extern *already-printed-exeeded-max-cache-tris* object) ;; symbol
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyport-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype boat-manager (process)
|
|
((mesh basic :offset-assert 128)
|
|
(paths path-control 4 :offset-assert 132) ;; guessed by decompiler
|
|
(boats-stop? basic :offset-assert 148)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x98
|
|
:flag-assert #x1100200098
|
|
(:methods
|
|
(boat-manager-method-15 () none) ;; 15 ;; (boat-manager-method-15 (_type_) none 15)
|
|
(boat-manager-method-16 () none) ;; 16
|
|
)
|
|
(:state-methods
|
|
idle ;; 14, old: (idle () _type_ :state 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype boat-base (vehicle)
|
|
((manager uint64 :offset-assert 696)
|
|
(angle float :offset-assert 704)
|
|
(y-rot float :offset-assert 708)
|
|
(path-num uint32 :offset-assert 712)
|
|
(path-index float :offset-assert 716)
|
|
)
|
|
:method-count-assert 152
|
|
:size-assert #x2d0
|
|
:flag-assert #x98025002d0
|
|
(:state-methods
|
|
waiting ;; 57
|
|
inactive ;; 56
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype barge (boat-base)
|
|
((engine sound-id :offset-assert 720) ;; guessed by decompiler
|
|
(bow-wash sound-id :offset-assert 724) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 152
|
|
:size-assert #x2d8
|
|
:flag-assert #x98026002d8
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *barge-constants* object) ;; rigid-body-vehicle-constants
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mine-ocean ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ocean-colors-mine* object)
|
|
;; (define-extern *ocean-near-indices-mine* ocean-near-indices)
|
|
;; (define-extern *ocean-trans-indices-mine* ocean-trans-indices)
|
|
;; (define-extern *ocean-mid-indices-mine* ocean-mid-indices)
|
|
;; (define-extern *ocean-mid-masks-mine* ocean-mid-masks)
|
|
;; (define-extern *ocean-map-mine* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; quaternion ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; quaternion is already defined!
|
|
|
|
;; (define-extern quaternion-axis-angle! function) ;; (function quaternion float float float float quaternion)
|
|
;; (define-extern quaternion-vector-angle! function) ;; (function quaternion vector float quaternion)
|
|
;; (define-extern vector-angle<-quaternion! function) ;; (function vector quaternion vector)
|
|
;; (define-extern quaternion-look-at! function) ;; (function quaternion vector vector quaternion)
|
|
;; (define-extern quaternion-zero! function) ;; (function quaternion quaternion)
|
|
;; (define-extern quaternion-identity! function) ;; (function quaternion quaternion)
|
|
;; (define-extern quaternion-i! function) ;; (function quaternion quaternion)
|
|
;; (define-extern quaternion-j! function) ;; (function quaternion quaternion)
|
|
;; (define-extern quaternion-k! function) ;; (function quaternion quaternion)
|
|
;; (define-extern quaternion-copy! function) ;; (function quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-set! function) ;; (function quaternion float float float float quaternion)
|
|
;; (define-extern quaternion+! function) ;; (function quaternion quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-! function) ;; (function quaternion quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-negate! function) ;; (function quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-conjugate! function) ;; (function quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-float*! function) ;; (function quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-float/! function) ;; (function quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-norm2 function) ;; (function quaternion float)
|
|
;; (define-extern quaternion-norm function) ;; (function quaternion float)
|
|
;; (define-extern quaternion-normalize! function) ;; (function quaternion quaternion)
|
|
;; (define-extern quaternion-inverse! function) ;; (function quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-dot function) ;; (function quaternion quaternion float)
|
|
;; (define-extern quaternion*! function) ;; (function quaternion quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-right-mult-matrix! function) ;; (function matrix quaternion matrix)
|
|
;; (define-extern quaternion-left-mult-matrix! function) ;; (function matrix quaternion matrix)
|
|
;; (define-extern quaternion->matrix function) ;; (function matrix quaternion matrix)
|
|
;; (define-extern quaternion->matrix-2 function) ;; (function matrix quaternion matrix)
|
|
;; (define-extern matrix->quaternion function) ;; (function quaternion matrix quaternion)
|
|
;; (define-extern matrix-with-scale->quaternion function) ;; (function quaternion matrix quaternion)
|
|
;; (define-extern quaternion-vector-len function) ;; (function quaternion float)
|
|
;; (define-extern quaternion-log! function) ;; (function quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-exp! function) ;; (function quaternion quaternion quaternion)
|
|
;; (define-extern quaternion-slerp! function) ;; (function quaternion quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-pseudo-slerp! function) ;; (function quaternion quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-pseudo-seek function) ;; (function quaternion quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-smooth-seek! function) ;; (function quaternion quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-zxy! function) ;; (function quaternion vector quaternion)
|
|
;; (define-extern vector-x-quaternion! function) ;; (function vector quaternion vector)
|
|
;; (define-extern vector-y-quaternion! function) ;; (function vector quaternion vector)
|
|
;; (define-extern vector-z-quaternion! function) ;; (function vector quaternion vector)
|
|
;; (define-extern quaternion-x-angle function) ;; (function quaternion float)
|
|
;; (define-extern quaternion-y-angle function) ;; (function quaternion float)
|
|
;; (define-extern quaternion-z-angle function) ;; (function quaternion float)
|
|
;; (define-extern quaternion-vector-y-angle function) ;; (function quaternion vector float)
|
|
;; (define-extern quaternion-rotate-local-x! function) ;; (function quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-rotate-local-y! function) ;; (function quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-rotate-local-z! function) ;; (function quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-rotate-y! function) ;; (function quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-rotate-x! function) ;; (function quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-rotate-z! function) ;; (function quaternion quaternion float quaternion)
|
|
;; (define-extern quaternion-delta-y function) ;; (function quaternion quaternion float)
|
|
;; (define-extern quaternion-rotate-y-to-vector! function) ;; (function quaternion quaternion quaternion float quaternion)
|
|
;; (define-extern vector-rotate-around-axis! function)
|
|
;; (define-extern vector-rotate-x! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-rotate-y! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-rotate-z! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-y-angle function) ;; (function vector float)
|
|
;; (define-extern vector-x-angle function) ;; (function vector float)
|
|
;; (define-extern quaternion<-rotate-y-vector function) ;; (function quaternion vector quaternion)
|
|
;; (define-extern quaternion-validate function) ;; (function quaternion none)
|
|
;; (define-extern quaternion-xz-angle function) ;; (function quaternion float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasgun-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype maker-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(hit-points float :offset-assert 16)
|
|
(targeted basic :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-wasgun (hud)
|
|
((offscreen uint8 :offset-assert 2756)
|
|
(numscores uint8 :offset-assert 2757)
|
|
(head-idx uint8 :offset-assert 2758)
|
|
(tail-idx uint8 :offset-assert 2759)
|
|
(maker-idx uint8 :offset-assert 2760)
|
|
(shoot-pos vector :inline :offset-assert 2768)
|
|
(minfo UNKNOWN 15 :offset-assert 2784)
|
|
(reticle UNKNOWN 20 :offset-assert 3264)
|
|
(position UNKNOWN 14 :offset-assert 4544)
|
|
(vel UNKNOWN 14 :offset-assert 4768)
|
|
(scores UNKNOWN 14 :offset-assert 4824)
|
|
(multiplier UNKNOWN 14 :offset-assert 4880)
|
|
(scoretimes UNKNOWN 14 :offset-assert 4896)
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #x1390
|
|
:flag-assert #x1d13101390
|
|
(:methods
|
|
(hud-wasgun-method-27 () none) ;; 27
|
|
(hud-wasgun-method-28 () none) ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype maker-grenade (projectile-bounce)
|
|
((minimap connection-minimap :offset-assert 548)
|
|
(blast-radius float :offset-assert 552)
|
|
(initial-dist float :offset-assert 556)
|
|
)
|
|
:method-count-assert 45
|
|
:size-assert #x230
|
|
:flag-assert #x2d01b00230
|
|
(:methods
|
|
(maker-grenade-method-44 () none) ;; 44
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-turret-hud-position (structure)
|
|
((x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-turret (target-turret)
|
|
((recoil UNKNOWN 2 :offset-assert 548)
|
|
(lerp float :offset-assert 556)
|
|
(lerp2 float :offset-assert 560)
|
|
(reticle-part basic :offset-assert 564)
|
|
(my-fire-time UNKNOWN 2 :offset-assert 568)
|
|
(ready-to-go-active basic :offset-assert 584)
|
|
(move-start uint64 :offset-assert 592)
|
|
(facing-ocean basic :offset-assert 600)
|
|
(facing-city basic :offset-assert 604)
|
|
(reset-facing basic :offset-assert 608)
|
|
(fire-delay basic :offset-assert 612)
|
|
(left? basic :offset-assert 616)
|
|
(fire-idx uint8 :offset-assert 620)
|
|
(speed-mult float :offset-assert 624)
|
|
(radar-object-counter uint16 :offset-assert 628)
|
|
(radar-object UNKNOWN 64 :offset-assert 632)
|
|
(aim-dir vector :inline :offset-assert 1664)
|
|
(reticle-dir vector :inline :offset-assert 1680)
|
|
(target-handle uint64 :offset-assert 1696)
|
|
)
|
|
:method-count-assert 63
|
|
:size-assert #x6a8
|
|
:flag-assert #x3f063006a8
|
|
(:methods
|
|
(wascity-turret-method-59 () none) ;; 59
|
|
(wascity-turret-method-60 () none) ;; 60
|
|
(wascity-turret-method-61 () none) ;; 61
|
|
(wascity-turret-method-62 () none) ;; 62
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype skeet (rigid-body-object)
|
|
((forw vector :inline :offset-assert 288)
|
|
(ppos vector :inline :offset-assert 304)
|
|
(pvel vector :inline :offset-assert 320)
|
|
(pacc vector :inline :offset-assert 336)
|
|
(angle float :offset-assert 352)
|
|
(disappear basic :offset-assert 356)
|
|
(rot-vel float :offset-assert 360)
|
|
(rot-acc float :offset-assert 364)
|
|
(initial-y float :offset-assert 368)
|
|
(time-to-live uint64 :offset-assert 376)
|
|
(birth-time uint64 :offset-assert 384)
|
|
(mult uint8 :offset-assert 392)
|
|
(score uint16 :offset-assert 394)
|
|
(minimap connection-minimap :offset-assert 396)
|
|
(skeet-type uint8 :offset-assert 400)
|
|
(skeet-sound uint32 :offset-assert 404)
|
|
(skeet-sound-playing? basic :offset-assert 408)
|
|
(mgr uint64 :offset-assert 416)
|
|
(mode uint8 :offset-assert 424)
|
|
)
|
|
:method-count-assert 63
|
|
:size-assert #x1a9
|
|
:flag-assert #x3f013001a9
|
|
(:methods
|
|
(skeet-method-56 () none) ;; 56
|
|
(skeet-method-57 () none) ;; 57
|
|
(skeet-method-58 () none) ;; 58
|
|
(skeet-method-59 () none) ;; 59
|
|
(skeet-method-60 () none) ;; 60
|
|
(skeet-method-61 () none) ;; 61
|
|
(skeet-method-62 () none) ;; 62
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-wasdef-damage (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; speech-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype speech-type-info (structure)
|
|
((channel uint8 :offset-assert 0)
|
|
(flags speech-type-flag :offset-assert 1)
|
|
(priority int8 :offset-assert 2)
|
|
(delay-pre-time uint16 :offset-assert 4)
|
|
(request-timeout uint16 :offset-assert 6)
|
|
(min-delay uint16 :offset-assert 8)
|
|
(max-delay uint16 :offset-assert 10)
|
|
(delay uint16 :offset-assert 12)
|
|
(play-index int16 :offset-assert 14)
|
|
(list (array string) :offset-assert 16) ;; guessed by decompiler
|
|
(time uint64 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
;; field speech-type-flag is likely a value type.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype speech-request (structure)
|
|
((handle uint64 :offset-assert 0) ;; handle
|
|
(time uint64 :offset-assert 8) ;; time-frame
|
|
(priority float :offset-assert 16)
|
|
(speech-type int8 :offset-assert 20) ;; speech-type
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x15
|
|
:flag-assert #x900000015
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype speech-channel (structure)
|
|
((flags speech-channel-flag :offset-assert 0)
|
|
(gui-channel uint8 :offset-assert 1) ;; gui-channel
|
|
(delay uint16 :offset-assert 2)
|
|
(id sound-id :offset-assert 4) ;; guessed by decompiler
|
|
(update-time uint64 :offset-assert 8) ;; time-frame
|
|
(start-time uint64 :offset-assert 16) ;; time-frame
|
|
(end-time uint64 :offset-assert 24) ;; time-frame
|
|
(request speech-request :inline :offset-assert 32)
|
|
(last-request speech-request :inline :offset-assert 56)
|
|
(target-pos vector :inline :offset-assert 80)
|
|
(speech-table (pointer speech-type-info) :offset-assert 96) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x64
|
|
:flag-assert #xf00000064
|
|
;; field speech-channel-flag is likely a value type.
|
|
(:methods
|
|
(speech-channel-method-9 () none) ;; 9 ;; (speech-channel-method-9 (_type_ process-drawable speech-type) none 9)
|
|
(speech-channel-method-10 () none) ;; 10 ;; (speech-channel-method-10 (_type_ handle) none 10)
|
|
(speech-channel-method-11 () none) ;; 11 ;; (speech-channel-method-11 (_type_) none 11)
|
|
(speech-channel-method-12 () none) ;; 12 ;; (speech-channel-method-12 (_type_) none 12)
|
|
(speech-channel-method-13 () none) ;; 13 ;; (speech-channel-method-13 (_type_) none 13)
|
|
(speech-channel-method-14 () none) ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype speech-control (structure)
|
|
((channel-array speech-channel 2 :offset-assert 0) ;; guessed by decompiler
|
|
(speech-table speech-type-info 61 :offset-assert 224) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x1d4
|
|
:flag-assert #x12000001d4
|
|
(:methods
|
|
(speech-control-method-9 () none) ;; 9 ;; (speech-control-method-9 (_type_) none 9)
|
|
(speech-control-method-10 () none) ;; 10 ;; (speech-table-set! (_type_ speech-type speech-type-info) none 10)
|
|
(speech-control-method-11 () none) ;; 11 ;; (speech-control-method-11 (_type_) none 11)
|
|
(speech-control-method-12 () none) ;; 12 ;; (speech-control-method-12 (_type_ process-drawable speech-type) none 12)
|
|
(speech-control-method-13 () none) ;; 13 ;; (speech-control-method-13 (_type_ handle) none 13)
|
|
(speech-control-method-14 () none) ;; 14 ;; (speech-control-method-14 (_type_) none 14)
|
|
(speech-control-method-15 () none) ;; 15 ;; (speech-control-method-15 (_type_ process-drawable) none 15)
|
|
(speech-control-method-16 () none) ;; 16 ;; (speech-control-method-16 (_type_) none 16)
|
|
(speech-control-method-17 () none) ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-touch-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype touching-prim (structure)
|
|
((cprim collide-shape-prim :offset-assert 0) ;; guessed by decompiler
|
|
(has-tri? symbol :offset-assert 4) ;; guessed by decompiler
|
|
(tri collide-tri-result :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x68
|
|
:flag-assert #x900000068
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype touching-prims-entry (structure)
|
|
((next touching-prims-entry :offset-assert 0)
|
|
(prev touching-prims-entry :offset-assert 4)
|
|
(allocated? symbol :offset-assert 8) ;; guessed by decompiler
|
|
(u float :offset-assert 12)
|
|
(prim1 touching-prim :inline :offset-assert 16)
|
|
(prim2 touching-prim :inline :offset-assert 128)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #xe8
|
|
:flag-assert #xd000000e8
|
|
(:methods
|
|
(touching-prims-entry-method-9 () none) ;; 9 ;; (get-middle-of-bsphere-overlap (_type_ vector) vector 9)
|
|
(touching-prims-entry-method-10 () none) ;; 10 ;; (get-touched-prim (_type_ collide-shape touching-shapes-entry) collide-shape-prim 10)
|
|
(touching-prims-entry-method-11 () none) ;; 11 ;; (get-touched-tri (_type_ collide-shape touching-shapes-entry) collide-tri-result 11)
|
|
(touching-prims-entry-method-12 () none) ;; 12
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype touching-prims-entry-pool (structure)
|
|
((head touching-prims-entry :offset-assert 0)
|
|
(nodes touching-prims-entry 64 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x3c10
|
|
:flag-assert #xd00003c10
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(touching-prims-entry-pool-method-9 () none) ;; 9 ;; (alloc-node (_type_) touching-prims-entry 9)
|
|
(touching-prims-entry-pool-method-10 () none) ;; 10 ;; (get-free-node-count (_type_) int 10)
|
|
(touching-prims-entry-pool-method-11 () none) ;; 11 ;; (init-list! (_type_) none 11)
|
|
(touching-prims-entry-pool-method-12 () none) ;; 12 ;; (free-node (_type_ touching-prims-entry) touching-prims-entry 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype touching-shapes-entry (structure)
|
|
((cshape1 collide-shape :offset-assert 0) ;; guessed by decompiler
|
|
(cshape2 collide-shape :offset-assert 4) ;; guessed by decompiler
|
|
(resolve-u int8 :offset-assert 8)
|
|
(head touching-prims-entry :offset-assert 12)
|
|
(handle1 uint64 :offset-assert 16) ;; handle
|
|
(handle2 uint64 :offset-assert 24) ;; handle
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x20
|
|
:flag-assert #xf00000020
|
|
(:methods
|
|
(touching-shapes-entry-method-9 () none) ;; 9 ;; (get-head (_type_) touching-prims-entry 9)
|
|
(touching-shapes-entry-method-10 () none) ;; 10 ;; (get-next (_type_ touching-shapes-entry) touching-prims-entry 10)
|
|
(touching-shapes-entry-method-11 () none) ;; 11 ;; (get-touched-shape (_type_ collide-shape) collide-shape 11)
|
|
(touching-shapes-entry-method-12 () none) ;; 12 ;; (prims-touching? (_type_ collide-shape uint) touching-prims-entry 12)
|
|
(touching-shapes-entry-method-13 () none) ;; 13 ;; (prims-touching-action? (_type_ collide-shape collide-action collide-action) basic 13)
|
|
(touching-shapes-entry-method-14 () none) ;; 14 ;; (free-touching-prims-list (_type_) none 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype touching-list (structure)
|
|
((num-touching-shapes int32 :offset-assert 0)
|
|
(resolve-u int8 :offset-assert 4)
|
|
(touching-shapes touching-shapes-entry 32 :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x408
|
|
:flag-assert #xe00000408
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(touching-list-method-9 () none) ;; 9 ;; (add-touching-prims (_type_ collide-shape-prim collide-shape-prim float collide-tri-result collide-tri-result) none 9)
|
|
(touching-list-method-10 () none) ;; 10 ;; (free-nodes (_type_) none 10)
|
|
(touching-list-method-11 () none) ;; 11 ;; (update-from-step-size (_type_ float) none 11)
|
|
(touching-list-method-12 () none) ;; 12 ;; (send-events-for-touching-shapes (_type_) none 12)
|
|
(touching-list-method-13 () none) ;; 13 ;; (get-shapes-entry (_type_ collide-shape collide-shape) touching-shapes-entry 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *touching-prims-entry-pool* object) ;; touching-prims-entry-pool
|
|
;; (define-extern *touching-list* object) ;; touching-list
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; euler ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern set-eul! function) ;; (function euler-angles float float float int euler-angles)
|
|
;; (define-extern eul->matrix function) ;; (function matrix euler-angles matrix)
|
|
;; (define-extern matrix->eul function) ;; (function euler-angles matrix int euler-angles)
|
|
;; (define-extern eul->quat function) ;; (function quaternion euler-angles quaternion)
|
|
;; (define-extern quat->eul function) ;; (function euler-angles quaternion int euler-angles)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flut ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *flut-shadow-control* shadow-control)
|
|
;; (define-extern *flut-color-table* array)
|
|
;; (define-extern flut-color-from-index function)
|
|
;; (define-extern flut-random-color-index function)
|
|
;; (define-extern flut-init function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; citizen-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype citizen (nav-enemy)
|
|
((flags citizen-flag :offset-assert 616)
|
|
(traffic-id int8 :offset-assert 618)
|
|
(hit-by-player-count int8 :offset-assert 619)
|
|
(gnd-height float :offset-assert 620)
|
|
(speed-scale float :offset-assert 624)
|
|
(controller vehicle-controller :inline :offset-assert 636)
|
|
(squad basic :offset-assert 780)
|
|
(danger-pos sphere :inline :offset-assert 796)
|
|
(dest-point vector :inline :offset-assert 700)
|
|
(vehicle uint64 :offset-assert 812) ;; handle
|
|
(formation uint64 :offset-assert 812)
|
|
(formation-index int8 :offset-assert 820)
|
|
(anim-shuffle int32 :offset-assert 824)
|
|
(dist-walk-anim float :offset-assert 828)
|
|
(speed-walk float :offset-assert 832)
|
|
(anim-walk int32 :offset-assert 836)
|
|
(dist-run-anim float :offset-assert 840)
|
|
(speed-run float :offset-assert 844)
|
|
(anim-run int32 :offset-assert 848)
|
|
(travel-anim-scale-speed float :offset-assert 852)
|
|
(water-anim int32 :offset-assert 856)
|
|
(interp float :offset-assert 860)
|
|
(last-danger-time uint64 :offset-assert 868) ;; time-frame
|
|
(next-time-look-at uint64 :offset-assert 876) ;; time-frame
|
|
(stop-time-look-at uint64 :offset-assert 884) ;; time-frame
|
|
(wait-return-state (state citizen) :offset-assert 892) ;; guessed by decompiler
|
|
(wait-time uint64 :offset-assert 900) ;; time-frame
|
|
(shield-handle uint64 :offset-assert 908)
|
|
(cp-valid? symbol :offset-assert 916) ;; guessed by decompiler
|
|
(cp-sphere sphere :inline :offset-assert 924)
|
|
(cp-vec vector :inline :offset-assert 940)
|
|
(cp-next-time uint64 :offset-assert 956) ;; time-frame
|
|
(cp-exit-time uint64 :offset-assert 964) ;; time-frame
|
|
(cp-force vector :inline :offset-assert 972)
|
|
(cp-plane plane :inline :offset-assert 988)
|
|
(cp-factor float :offset-assert 1004)
|
|
(faction-mode uint8 :offset-assert 1008)
|
|
(attacker-info city-attacker-info :offset-assert 1012)
|
|
(mission-squad basic :offset-assert 1016)
|
|
(probe-counter uint32 :offset-assert 1020)
|
|
)
|
|
:method-count-assert 216
|
|
:size-assert #x404
|
|
:flag-assert #xd803900404
|
|
;; field citizen-flag is likely a value type.
|
|
(:methods
|
|
(citizen-method-190 () none) ;; 190 ;; (citizen-method-190 (_type_ vector) none 190)
|
|
(citizen-method-191 () none) ;; 191 ;; (gen-clear-path (_type_) nav-segment 191)
|
|
(citizen-method-192 () none) ;; 192 ;; (citizen-method-192 (_type_) none 192)
|
|
(citizen-method-193 () none) ;; 193 ;; (throw-off-vehicle (_type_) none 193)
|
|
(citizen-method-194 () none) ;; 194 ;; (gen-new-dir (_type_ vector float) nav-segment 194)
|
|
(citizen-method-195 () none) ;; 195 ;; (citizen-method-195 (_type_ vector) symbol 195)
|
|
(citizen-method-196 () none) ;; 196 ;; (get-run-anim (_type_) int 196)
|
|
(citizen-method-197 () none) ;; 197 ;; (trigger-alert (_type_ int target) none 197)
|
|
(citizen-method-198 () none) ;; 198 ;; (decrease-alert (_type_ object) none 198)
|
|
(citizen-method-199 () none) ;; 199 ;; (set-behavior! (_type_ traffic-object-spawn-params) none 199)
|
|
(citizen-method-200 () none) ;; 200 ;; (citizen-method-200 (_type_) none 200)
|
|
(citizen-method-201 () none) ;; 201
|
|
(citizen-method-202 () none) ;; 202
|
|
(citizen-method-203 () none) ;; 203
|
|
(citizen-method-204 () none) ;; 204
|
|
(citizen-method-205 () none) ;; 205
|
|
(citizen-method-206 () none) ;; 206
|
|
(citizen-method-207 () none) ;; 207
|
|
(citizen-method-208 () none) ;; 208
|
|
(citizen-method-209 () none) ;; 209
|
|
(citizen-method-210 () none) ;; 210
|
|
(citizen-method-211 () none) ;; 211
|
|
(citizen-method-212 () none) ;; 212
|
|
(citizen-method-213 () none) ;; 213
|
|
(citizen-method-214 () none) ;; 214
|
|
(citizen-method-215 () none) ;; 215
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; profile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype profile-work (structure)
|
|
((sprite-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(line-tmpl dma-gif-packet :inline :offset-assert 32)
|
|
(last-index int32 :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *profile-spec-array* object)
|
|
;; (define-extern *profile-translate-array* object)
|
|
;; (define-extern *profile-work* object) ;; profile-work
|
|
;; (define-extern *profile-x* object) ;; int
|
|
;; (define-extern *profile-y* object) ;; int
|
|
;; (define-extern *profile-w* object) ;; int
|
|
;; (define-extern *profile-h* object) ;; int
|
|
;; (define-extern *profile-ticks* object) ;; symbol
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-training ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-hover (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-token (process-focusable)
|
|
((part-trail basic :offset-assert 208)
|
|
(actor-group uint32 :offset-assert 212)
|
|
(actor-group-count int32 :offset-assert 216)
|
|
(part-subsampler basic :offset-assert 220)
|
|
(path-pos float :offset-assert 224)
|
|
(speed float :offset-assert 228)
|
|
(velocity vector :inline :offset-assert 240)
|
|
(group-num uint32 :offset-assert 256)
|
|
(camera-done? uint32 :offset-assert 260)
|
|
(dest vector :inline :offset-assert 272)
|
|
(sound-id uint32 :offset-assert 288)
|
|
(minimap connection-minimap :offset-assert 292)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #x128
|
|
:flag-assert #x1f00b00128
|
|
(:state-methods
|
|
idle ;; 28
|
|
die-fast ;; 30
|
|
go-door ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-training-manager (process)
|
|
((actor-group uint32 :offset-assert 124)
|
|
(actor-group-count int32 :offset-assert 128)
|
|
(gui-id uint32 :offset-assert 132)
|
|
(text basic :offset-assert 136)
|
|
(hud-counter uint64 :offset-assert 140)
|
|
(text-id uint32 :offset-assert 148)
|
|
)
|
|
:method-count-assert 19
|
|
:size-assert #x9c
|
|
:flag-assert #x130020009c
|
|
(:methods
|
|
(hover-training-manager-method-18 () none) ;; 18
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
done ;; 15
|
|
die-fast ;; 16
|
|
display-text ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-symbol (process-drawable)
|
|
((flash-time uint64 :offset-assert 200)
|
|
(part-touched basic :offset-assert 208)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xd4
|
|
:flag-assert #x15006000d4
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; trigonometry ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern radmod function) ;; (function float float)
|
|
;; (define-extern deg- function) ;; (function float float float)
|
|
;; (define-extern deg-diff function) ;; (function float float float)
|
|
;; (define-extern deg-seek function) ;; (function float float float float)
|
|
;; (define-extern deg-seek-smooth function) ;; (function float float float float float)
|
|
;; (define-extern deg-lerp-clamp function) ;; (function float float float float)
|
|
;; (define-extern binary-table array) ;; (array float)
|
|
;; (define-extern sincos-table array) ;; (array float)
|
|
;; (define-extern sin function) ;; (function float float)
|
|
;; (define-extern sin-rad function) ;; (function float float)
|
|
;; (define-extern *sin-poly-vec* object) ;; vector
|
|
;; (define-extern *sin-poly-vec2* object) ;; vector
|
|
;; (define-extern vector-sin-rad! function) ;; (function vector vector vector)
|
|
;; (define-extern cos-rad function) ;; (function float float)
|
|
;; (define-extern *cos-poly-vec* object) ;; vector
|
|
;; (define-extern vector-cos-rad! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-sincos-rad! function) ;; (function vector vector vector int)
|
|
;; (define-extern sincos-rad! function) ;; (function vector float int)
|
|
;; (define-extern sincos! function) ;; (function vector float int)
|
|
;; (define-extern vector-rad<-vector-deg! function) ;; (function vector vector none)
|
|
;; (define-extern vector-rad<-vector-deg/2! function) ;; (function vector vector int)
|
|
;; (define-extern vector-sincos! function) ;; (function vector vector vector int)
|
|
;; (define-extern tan-rad function) ;; (function float float)
|
|
;; (define-extern cos function) ;; (function float float)
|
|
;; (define-extern tan function) ;; (function float float)
|
|
;; (define-extern atan0 function) ;; (function float float float)
|
|
;; (define-extern atan-series-rad function) ;; (function float float)
|
|
;; (define-extern atan-rad function) ;; (function float float)
|
|
;; (define-extern sign-bit function) ;; (function int int)
|
|
;; (define-extern sign-float function) ;; (function float float)
|
|
;; (define-extern sign function) ;; (function float float)
|
|
;; (define-extern atan2-rad function) ;; (function float float float)
|
|
;; (define-extern atan function) ;; (function float float float)
|
|
;; (define-extern asin function) ;; (function float float)
|
|
;; (define-extern acos function) ;; (function float float)
|
|
;; (define-extern acos-rad function) ;; (function float float)
|
|
;; (define-extern sinerp function) ;; (function float float float float)
|
|
;; (define-extern sinerp-clamp function) ;; (function float float float float)
|
|
;; (define-extern coserp function) ;; (function float float float float)
|
|
;; (define-extern coserp-clamp function) ;; (function float float float float)
|
|
;; (define-extern coserp180 function) ;; (function float float float float)
|
|
;; (define-extern coserp180-clamp function) ;; (function float float float float)
|
|
;; (define-extern ease-in-out function) ;; (function int int float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; enemy-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype enemy-focus (focus)
|
|
((aware uint64 :offset-assert 16) ;; enemy-aware
|
|
(flags uint64 :offset-assert 24) ;; enemy-flag
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x20
|
|
:flag-assert #xe00000020
|
|
(:methods
|
|
(enemy-focus-method-13 () none) ;; 13 ;; (enemy-focus-method-13 (_type_ process-focusable enemy-aware) symbol 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype enemy-info (basic)
|
|
((fact-defaults fact-info-enemy-defaults :offset-assert 4) ;; guessed by decompiler
|
|
(use-die-falling symbol :offset-assert 8) ;; guessed by decompiler
|
|
(use-victory symbol :offset-assert 12) ;; guessed by decompiler
|
|
(use-jump-blocked symbol :offset-assert 16) ;; guessed by decompiler
|
|
(debug-draw-neck symbol :offset-assert 20) ;; guessed by decompiler
|
|
(jump-debug-draw symbol :offset-assert 24) ;; guessed by decompiler
|
|
(move-to-ground symbol :offset-assert 28) ;; guessed by decompiler
|
|
(hover-if-no-ground symbol :offset-assert 32) ;; guessed by decompiler
|
|
(idle-anim-script (pointer idle-control-frame) :offset-assert 36) ;; guessed by decompiler
|
|
(idle-anim int32 :offset-assert 40)
|
|
(notice-anim int32 :offset-assert 44)
|
|
(hostile-anim int32 :offset-assert 48)
|
|
(hit-anim int32 :offset-assert 52)
|
|
(knocked-anim int32 :offset-assert 56)
|
|
(knocked-land-anim int32 :offset-assert 60)
|
|
(die-anim int32 :offset-assert 64)
|
|
(die-falling-anim int32 :offset-assert 68)
|
|
(victory-anim int32 :offset-assert 72)
|
|
(jump-wind-up-anim int32 :offset-assert 76)
|
|
(jump-in-air-anim int32 :offset-assert 80)
|
|
(jump-land-anim int32 :offset-assert 84)
|
|
(neck-joint int32 :offset-assert 88)
|
|
(look-at-joint int32 :offset-assert 92)
|
|
(bullseye-joint int32 :offset-assert 96)
|
|
(sound-hit uint128 :offset-assert 112) ;; sound-name
|
|
(sound-die uint128 :offset-assert 128) ;; sound-name
|
|
(notice-distance meters :offset-assert 144)
|
|
(notice-distance-delta meters :offset-assert 148)
|
|
(proximity-notice-distance meters :offset-assert 152)
|
|
(default-hit-points float :offset-assert 156) ;; int32
|
|
(gnd-collide-with collide-spec :offset-assert 160) ;; guessed by decompiler
|
|
(overlaps-others-collide-with-filter collide-spec :offset-assert 164) ;; guessed by decompiler
|
|
(penetrate-flinch uint64 :offset-assert 168) ;; penetrate
|
|
(penetrate-knocked uint64 :offset-assert 176) ;; penetrate
|
|
(movement-gravity meters :offset-assert 184)
|
|
(friction float :offset-assert 188)
|
|
(slip-factor float :offset-assert 192)
|
|
(attack-shove-back meters :offset-assert 196)
|
|
(attack-shove-up meters :offset-assert 200)
|
|
(attack-mode symbol :offset-assert 204) ;; guessed by decompiler
|
|
(attack-damage int32 :offset-assert 208)
|
|
(recover-gnd-collide-with collide-spec :offset-assert 212) ;; guessed by decompiler
|
|
(knocked-can-land-timeout uint64 :offset-assert 216)
|
|
(knocked-recover-timeout uint64 :offset-assert 224)
|
|
(ragdoll-blend-out-time uint64 :offset-assert 232)
|
|
(ragdoll-rotate-velocity-mult float :offset-assert 240)
|
|
(jump-height-min meters :offset-assert 244)
|
|
(jump-height-factor float :offset-assert 248)
|
|
(knocked-seek-ry-clamp float :offset-assert 252)
|
|
(knocked-soft-vxz-lo float :offset-assert 256)
|
|
(knocked-soft-vxz-hi float :offset-assert 260)
|
|
(knocked-soft-vy-lo float :offset-assert 264)
|
|
(knocked-soft-vy-hi float :offset-assert 268)
|
|
(knocked-medium-vxz-lo float :offset-assert 272)
|
|
(knocked-medium-vxz-hi float :offset-assert 276)
|
|
(knocked-medium-vy-lo float :offset-assert 280)
|
|
(knocked-medium-vy-hi float :offset-assert 284)
|
|
(knocked-hard-vxz-lo float :offset-assert 288)
|
|
(knocked-hard-vxz-hi float :offset-assert 292)
|
|
(knocked-hard-vy-lo float :offset-assert 296)
|
|
(knocked-hard-vy-hi float :offset-assert 300)
|
|
(knocked-huge-vxz-lo float :offset-assert 304)
|
|
(knocked-huge-vxz-hi float :offset-assert 308)
|
|
(knocked-huge-vy-lo float :offset-assert 312)
|
|
(knocked-huge-vy-hi float :offset-assert 316)
|
|
(knocked-yellow-vxz-lo float :offset-assert 320)
|
|
(knocked-yellow-vxz-hi float :offset-assert 324)
|
|
(knocked-yellow-vy-lo float :offset-assert 328)
|
|
(knocked-yellow-vy-hi float :offset-assert 332)
|
|
(knocked-red-vxz-lo float :offset-assert 336)
|
|
(knocked-red-vxz-hi float :offset-assert 340)
|
|
(knocked-red-vy-lo float :offset-assert 344)
|
|
(knocked-red-vy-hi float :offset-assert 348)
|
|
(knocked-blue-vxz-lo float :offset-assert 352)
|
|
(knocked-blue-vxz-hi float :offset-assert 356)
|
|
(knocked-blue-vy-lo float :offset-assert 360)
|
|
(knocked-blue-vy-hi float :offset-assert 364)
|
|
(ragdoll-info ragdoll-setup :offset-assert 368)
|
|
(shadow-size meters :offset-assert 372)
|
|
(shadow-max-y meters :offset-assert 376)
|
|
(shadow-min-y meters :offset-assert 380)
|
|
(shadow-locus-dist meters :offset-assert 384)
|
|
(gem-joint int32 :offset-assert 388)
|
|
(gem-seg uint32 :offset-assert 392)
|
|
(gem-no-seg uint32 :offset-assert 396)
|
|
(gem-offset sphere :inline :offset-assert 400)
|
|
(knocked-off basic :offset-assert 416)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x1a4
|
|
:flag-assert #xa000001a4
|
|
(:methods
|
|
(enemy-info-method-9 () none) ;; 9 ;; (copy-enemy-info! (_type_ _type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype enemy-knocked-info (structure)
|
|
((anim-speed float :offset-assert 0)
|
|
(on-surface-count int32 :offset-assert 4)
|
|
(move-count int32 :offset-assert 8)
|
|
(land-can-land-time uint64 :offset-assert 16) ;; time-frame
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype enemy-jump-info (structure)
|
|
((flags uint8 :offset-assert 0) ;; enemy-jump-flags
|
|
(anim-speed float :offset-assert 4)
|
|
(hang-time uint64 :offset-assert 8) ;; time-frame
|
|
(start-pos vector :inline :offset-assert 16)
|
|
(dest-pos vector :inline :offset-assert 32)
|
|
(traj trajectory :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x58
|
|
:flag-assert #x900000058
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype enemy-init-by-other-params (structure)
|
|
((trans vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(entity entity :offset-assert 32) ;; guessed by decompiler
|
|
(directed? symbol :offset-assert 36) ;; guessed by decompiler
|
|
(no-initial-move-to-ground? symbol :offset-assert 40) ;; guessed by decompiler
|
|
(art-level basic :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype enemy-attack-info (structure)
|
|
((attack-id uint32 :offset-assert 0)
|
|
(knocked-type uint8 :offset-assert 4) ;; knocked-type
|
|
(blue-juggle-count uint8 :offset-assert 5)
|
|
(attacker-handle uint64 :offset-assert 8) ;; handle
|
|
(attack-time uint64 :offset-assert 16) ;; time-frame
|
|
(penetrate-using uint64 :offset-assert 24) ;; penetrate
|
|
(attacker-pos vector :inline :offset-assert 32)
|
|
(attack-direction vector :inline :offset-assert 48)
|
|
(attack-position vector :inline :offset-assert 64)
|
|
(intensity float :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x54
|
|
:flag-assert #x900000054
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype enemy-best-focus (structure)
|
|
((proc process :offset-assert 0) ;; guessed by decompiler
|
|
(rating float :offset-assert 4)
|
|
(aware uint64 :offset-assert 8) ;; enemy-aware
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype enemy (process-focusable)
|
|
((enemy-flags enemy-flag :offset-assert 208)
|
|
(enemy-info enemy-info :offset-assert 216) ;; guessed by decompiler
|
|
(hit-points float :offset-assert 220) ;; int32
|
|
(gnd-collide-with uint32 :offset-assert 224)
|
|
(attack-id uint32 :offset-assert 228)
|
|
(persistent-attack-id uint32 :offset-assert 232)
|
|
(water-max-height float :offset-assert 236) ;; meters
|
|
(water-surface-height float :offset-assert 240) ;; meters
|
|
(desired-angle float :offset-assert 244) ;; degrees
|
|
(jump-why uint64 :offset-assert 248)
|
|
(penetrated-by-all uint64 :offset-assert 256) ;; penetrate
|
|
(penetrate-flinch uint64 :offset-assert 264)
|
|
(penetrate-knocked uint64 :offset-assert 272)
|
|
(ragdoll-proc uint64 :offset-assert 280)
|
|
(reaction-time uint64 :offset-assert 288) ;; time-frame
|
|
(notice-time uint64 :offset-assert 296) ;; time-frame
|
|
(state-timeout uint64 :offset-assert 304) ;; time-frame
|
|
(auto-reset-penetrate-time uint64 :offset-assert 312) ;; time-frame
|
|
(hit-focus-time uint64 :offset-assert 320) ;; time-frame
|
|
(last-draw-time uint64 :offset-assert 328) ;; time-frame
|
|
(starting-time uint64 :offset-assert 336) ;; time-frame
|
|
(fated-time uint64 :offset-assert 344) ;; time-frame
|
|
(focus-pos vector :inline :offset-assert 352)
|
|
(event-param-point vector :inline :offset-assert 368)
|
|
(jump-dest vector :inline :offset-assert 368)
|
|
(focus enemy-focus :inline :offset-assert 384)
|
|
(incoming enemy-attack-info :inline :offset-assert 416)
|
|
(actor-group (pointer actor-group) :offset-assert 500) ;; guessed by decompiler
|
|
(actor-group-count int32 :offset-assert 504)
|
|
(neck joint-mod :offset-assert 508) ;; guessed by decompiler
|
|
(on-notice pair :offset-assert 512) ;; guessed by decompiler
|
|
(on-active pair :offset-assert 516) ;; guessed by decompiler
|
|
(on-hostile pair :offset-assert 520) ;; guessed by decompiler
|
|
(on-death pair :offset-assert 524) ;; guessed by decompiler
|
|
(idle-anim-player idle-control :inline :offset-assert 528)
|
|
(rand-gen symbol :offset-assert 548) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 155
|
|
:size-assert #x228
|
|
:flag-assert #x9b01b00228
|
|
;; field enemy-flag is likely a value type. field on-notice uses ~A with a signed load. field on-active uses ~A with a signed load. field on-hostile uses ~A with a signed load. field on-death uses ~A with a signed load.
|
|
(:methods
|
|
(enemy-method-28 () none) ;; 28 ;; (dormant-aware () _type_ :state 28)
|
|
(enemy-method-29 () none) ;; 29 ;; (hit () _type_ :state 29)
|
|
(enemy-method-30 () none) ;; 30 ;; (knocked () _type_ :state 30)
|
|
(enemy-method-31 () none) ;; 31 ;; (idle () _type_ :state 31)
|
|
(enemy-method-32 () none) ;; 32 ;; (active () _type_ :state 32)
|
|
(enemy-method-33 () none) ;; 33 ;; (notice () _type_ :state 33)
|
|
(enemy-method-34 () none) ;; 34 ;; (flee () _type_ :state 34)
|
|
(enemy-method-35 () none) ;; 35 ;; (stare () _type_ :state 35)
|
|
(enemy-method-36 () none) ;; 36 ;; (hostile () _type_ :state 36)
|
|
(enemy-method-37 () none) ;; 37 ;; (victory () _type_ :state 37)
|
|
(enemy-method-38 () none) ;; 38 ;; (die () _type_ :state 38)
|
|
(enemy-method-39 () none) ;; 39 ;; (die-falling () _type_ :state 39)
|
|
(enemy-method-40 () none) ;; 40 ;; (die-fast () _type_ :state 40)
|
|
(enemy-method-41 () none) ;; 41 ;; (directed () _type_ :state 41)
|
|
(enemy-method-42 () none) ;; 42 ;; (jump () _type_ :state 42)
|
|
(enemy-method-43 () none) ;; 43 ;; (jump-blocked () _type_ :state 43)
|
|
(enemy-method-44 () none) ;; 44 ;; (ambush () _type_ :state 44)
|
|
(enemy-method-45 () none) ;; 45 ;; (view-anims () _type_ :state 45)
|
|
(enemy-method-46 () none) ;; 46 ;; (enemy-method-46 (_type_ int) none 46)
|
|
(enemy-method-47 () none) ;; 47 ;; (enemy-method-47 (_type_ vector) float 47)
|
|
(enemy-method-48 () none) ;; 48 ;; (take-damage-from-attack (_type_ process event-message-block) int 48)
|
|
(enemy-method-49 () none) ;; 49 ;; (enemy-method-49 (_type_) time-frame 49)
|
|
(enemy-method-50 () none) ;; 50 ;; (enemy-method-50 (_type_ vector) vector 50)
|
|
(enemy-method-51 () none) ;; 51 ;; (enemy-method-51 (_type_) float 51)
|
|
(enemy-method-52 () none) ;; 52 ;; (enemy-method-52 (_type_ vector) none 52)
|
|
(enemy-method-53 () none) ;; 53 ;; (enemy-method-53 (_type_ process-focusable) symbol 53)
|
|
(enemy-method-54 () none) ;; 54 ;; (enemy-method-54 (_type_) enemy-flag 54)
|
|
(enemy-method-55 () none) ;; 55 ;; (common-post (_type_) none 55)
|
|
(enemy-method-56 () none) ;; 56 ;; (damage-amount-from-attack (_type_ process event-message-block) int 56)
|
|
(enemy-method-57 () none) ;; 57 ;; (update-target-awareness! (_type_ process-focusable enemy-best-focus) enemy-aware 57)
|
|
(enemy-method-58 () none) ;; 58 ;; (enemy-method-58 (_type_ process event-message-block) symbol 58)
|
|
(enemy-method-59 () none) ;; 59 ;; (get-penetrate-info (_type_) penetrate 59)
|
|
(enemy-method-60 () none) ;; 60 ;; (coin-flip? (_type_) symbol 60)
|
|
(enemy-method-61 () none) ;; 61 ;; (enemy-method-61 (_type_ int) int 61)
|
|
(enemy-method-62 () none) ;; 62 ;; (enemy-method-62 (_type_) none 62)
|
|
(enemy-method-63 () none) ;; 63 ;; (enemy-method-63 (_type_ process-focusable enemy-aware) symbol 63)
|
|
(enemy-method-64 () none) ;; 64 ;; (go-dormant (_type_) object 64)
|
|
(enemy-method-65 () none) ;; 65 ;; (go-dormant-aware (_type_) object 65)
|
|
(enemy-method-66 () none) ;; 66 ;; (go-ambush (_type_) object 66)
|
|
(enemy-method-67 () none) ;; 67 ;; (go-stare (_type_) object 67)
|
|
(enemy-method-68 () none) ;; 68 ;; (go-stare2 (_type_) object 68)
|
|
(enemy-method-69 () none) ;; 69 ;; (go-directed (_type_) object 69)
|
|
(enemy-method-70 () none) ;; 70 ;; (go-hostile (_type_) object 70)
|
|
(enemy-method-71 () none) ;; 71 ;; (go-flee (_type_) object 71)
|
|
(enemy-method-72 () none) ;; 72 ;; (react-to-focus (_type_) object 72)
|
|
(enemy-method-73 () none) ;; 73 ;; (kill-prefer-falling (_type_) object 73)
|
|
(enemy-method-74 () none) ;; 74 ;; (general-event-handler (_type_ process int symbol event-message-block) object 74)
|
|
(enemy-method-75 () none) ;; 75 ;; (enemy-method-75 (_type_ process event-message-block) object 75)
|
|
(enemy-method-76 () none) ;; 76 ;; (enemy-method-76 (_type_ process event-message-block) symbol 76)
|
|
(enemy-method-77 () none) ;; 77 ;; (enemy-method-77 (_type_ enemy-knocked-info) symbol 77)
|
|
(enemy-method-78 () none) ;; 78 ;; (enemy-method-78 (_type_ enemy-knocked-info) symbol 78)
|
|
(enemy-method-79 () none) ;; 79 ;; (enemy-method-79 (_type_ int enemy-knocked-info) symbol 79)
|
|
(enemy-method-80 () none) ;; 80 ;; (enemy-method-80 (_type_ enemy-knocked-info) symbol 80)
|
|
(enemy-method-81 () none) ;; 81 ;; (enemy-method-81 (_type_) symbol 81)
|
|
(enemy-method-82 () none) ;; 82 ;; (enemy-method-82 (_type_ enemy-jump-info) symbol 82)
|
|
(enemy-method-83 () none) ;; 83 ;; (enemy-method-83 (_type_ enemy-jump-info) none 83)
|
|
(enemy-method-84 () none) ;; 84 ;; (enemy-method-84 (_type_ enemy-jump-info) none 84)
|
|
(enemy-method-85 () none) ;; 85 ;; (enemy-method-85 (_type_) float 85)
|
|
(enemy-method-86 () none) ;; 86 ;; (enemy-method-86 (_type_) symbol 86)
|
|
(enemy-method-87 () none) ;; 87 ;; (enemy-method-87 (_type_ enemy-jump-info) symbol 87)
|
|
(enemy-method-88 () none) ;; 88 ;; (enemy-method-88 (_type_ enemy-jump-info) symbol 88)
|
|
(enemy-method-89 () none) ;; 89 ;; (enemy-method-89 (_type_ enemy-jump-info) symbol 89)
|
|
(enemy-method-90 () none) ;; 90 ;; (enemy-method-90 (_type_ int enemy-jump-info) symbol 90)
|
|
(enemy-method-91 () none) ;; 91 ;; (enemy-method-91 (_type_ int enemy-jump-info) none 91)
|
|
(enemy-method-92 () none) ;; 92 ;; (enemy-method-92 (_type_ int enemy-jump-info) none 92)
|
|
(enemy-method-93 () none) ;; 93 ;; (enemy-method-93 (_type_) none 93)
|
|
(enemy-method-94 () none) ;; 94 ;; (enemy-method-94 (_type_ vector float) symbol 94)
|
|
(enemy-method-95 () none) ;; 95 ;; (enemy-method-95 (_type_ vector float) symbol 95)
|
|
(enemy-method-96 () none) ;; 96 ;; (enemy-method-96 (_type_ float symbol) symbol 96)
|
|
(enemy-method-97 () none) ;; 97 ;; (enemy-method-97 (_type_) process 97)
|
|
(enemy-method-98 () none) ;; 98 ;; (in-aggro-range? (_type_ process-focusable vector) symbol 98)
|
|
(enemy-method-99 () none) ;; 99 ;; (enemy-method-99 (_type_ process-focusable) symbol 99)
|
|
(enemy-method-100 () none) ;; 100 ;; (enemy-method-100 (_type_) symbol 100)
|
|
(enemy-method-101 () none) ;; 101 ;; (enemy-method-101 (_type_) none 101)
|
|
(enemy-method-102 () none) ;; 102 ;; (enemy-method-102 (_type_) symbol 102)
|
|
(enemy-method-103 () none) ;; 103 ;; (enemy-method-103 (_type_) collide-spec 103)
|
|
(enemy-method-104 () none) ;; 104 ;; (enemy-method-104 (_type_ process touching-shapes-entry uint) symbol 104)
|
|
(enemy-method-105 () none) ;; 105 ;; (enemy-method-105 (_type_ process) enemy-flag 105)
|
|
(enemy-method-106 () none) ;; 106 ;; (set-incoming-attack-info (_type_ process object penetrate attack-info) none 106)
|
|
(enemy-method-107 () none) ;; 107 ;; (get-enemy-target (_type_) process-focusable 107)
|
|
(enemy-method-108 () none) ;; 108 ;; (enemy-method-108 (_type_ process-drawable event-message-block) int 108)
|
|
(enemy-method-109 () none) ;; 109 ;; (look-at-target! (_type_ enemy-flag) none 109)
|
|
(enemy-method-110 () none) ;; 110 ;; (stop-looking-at-target! (_type_) none 110)
|
|
(enemy-method-111 () none) ;; 111 ;; (enemy-method-111 (_type_) none 111)
|
|
(enemy-method-112 () none) ;; 112 ;; (set-enemy-info! (_type_ enemy-info) none 112)
|
|
(enemy-method-113 () none) ;; 113 ;; (init-enemy-behaviour-and-stats! (_type_ enemy-info) none 113)
|
|
(enemy-method-114 () none) ;; 114 ;; (init-enemy-collision! (_type_) none 114)
|
|
(enemy-method-115 () none) ;; 115 ;; (init-enemy! (_type_) none 115)
|
|
(enemy-method-116 () none) ;; 116 ;; (go-idle (_type_) none 116)
|
|
(enemy-method-117 () none) ;; 117 ;; (rnd-float (_type_) float 117)
|
|
(enemy-method-118 () none) ;; 118 ;; (rnd-float-range (_type_ float float) float 118)
|
|
(enemy-method-119 () none) ;; 119 ;; (rnd-int-count (_type_ int) int 119)
|
|
(enemy-method-120 () none) ;; 120 ;; (rnd-bit (_type_ int int) int 120)
|
|
(enemy-method-121 () none) ;; 121 ;; (rnd-int-range (_type_ int int) int 121)
|
|
(enemy-method-122 () none) ;; 122 ;; (rnd-percent? (_type_ float) symbol 122)
|
|
(enemy-method-123 () none) ;; 123 ;; (rnd-go-idle? (_type_ float) symbol 123)
|
|
(enemy-method-124 () none) ;; 124 ;; (enemy-method-124 (_type_) collide-spec 124)
|
|
(enemy-method-125 () none) ;; 125 ;; (ground-pat-set! (_type_ collide-query collide-spec float float float) pat-surface 125)
|
|
(enemy-method-126 () none) ;; 126 ;; (enemy-above-ground? (_type_ collide-query vector collide-spec float float float) symbol 126)
|
|
(enemy-method-127 () none) ;; 127 ;; (enemy-method-127 (_type_ float float symbol collide-spec) symbol 127)
|
|
(enemy-method-128 () none) ;; 128 ;; (enemy-method-128 (_type_ vector move-above-ground-params) none 128)
|
|
(enemy-method-129 () none) ;; 129 ;; (enemy-method-129 (_type_) none 129)
|
|
(enemy-method-130 () none) ;; 130 ;; (enemy-method-130 (_type_ float) symbol 130)
|
|
(enemy-method-131 () none) ;; 131 ;; (penetrate-using->knocked (_type_ penetrate) knocked-type 131)
|
|
(enemy-method-132 () none) ;; 132 ;; (dying (_type_) none 132)
|
|
(enemy-method-133 () none) ;; 133 ;; (enemy-method-133 (_type_) symbol 133)
|
|
(enemy-method-134 () none) ;; 134 ;; (get-attacker (_type_ process attack-info) process-focusable 134)
|
|
(enemy-method-135 () none) ;; 135 ;; (enemy-method-135 (_type_ int) sound-id 135)
|
|
(enemy-method-136 () none) ;; 136 ;; (enemy-method-136 (_type_) enemy-flag 136)
|
|
(enemy-method-137 () none) ;; 137
|
|
(enemy-method-138 () none) ;; 138
|
|
(enemy-method-139 () none) ;; 139
|
|
(enemy-method-140 () none) ;; 140
|
|
(enemy-method-141 () none) ;; 141
|
|
(enemy-method-142 () none) ;; 142
|
|
(enemy-method-143 () none) ;; 143
|
|
(enemy-method-144 () none) ;; 144
|
|
(enemy-method-145 () none) ;; 145
|
|
(enemy-method-146 () none) ;; 146
|
|
(enemy-method-147 () none) ;; 147
|
|
(enemy-method-148 () none) ;; 148
|
|
(enemy-method-149 () none) ;; 149
|
|
(enemy-method-150 () none) ;; 150
|
|
(enemy-method-151 () none) ;; 151
|
|
(enemy-method-152 () none) ;; 152
|
|
(enemy-method-153 () none) ;; 153
|
|
(enemy-method-154 () none) ;; 154
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype anim-info (structure)
|
|
((anim-index int32 :offset-assert 0)
|
|
(travel-speed meters :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; des-bush-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *bb-ring-alpha* object)
|
|
;; (define-extern spt-func-bb-ring-fader function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gsound-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sound-stream-name (structure)
|
|
((name uint8 48 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
;; (deftype sound-id (uint32)
|
|
;; ()
|
|
;; :flag-assert #xa00000004
|
|
;; )
|
|
|
|
;; (deftype sound-bank-id (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype sound-name (uint128)
|
|
;; ()
|
|
;; :flag-assert #x900000010
|
|
;; )
|
|
|
|
#|
|
|
(deftype sound-rpc-cmd (structure)
|
|
((rsvd1 uint16 :offset-assert 0)
|
|
(command uint16 :offset-assert 2) ;; sound-command
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-play-params (structure)
|
|
((mask uint16 :offset-assert 0)
|
|
(pitch-mod int16 :offset-assert 2)
|
|
(bend int16 :offset-assert 4)
|
|
(fo-min int16 :offset-assert 6)
|
|
(fo-max int16 :offset-assert 8)
|
|
(fo-curve int8 :offset-assert 10)
|
|
(priority int8 :offset-assert 11)
|
|
(volume int32 :offset-assert 12)
|
|
(trans int32 3 :offset-assert 16) ;; guessed by decompiler
|
|
(group uint8 :offset-assert 28)
|
|
(reg uint8 3 :offset-assert 29) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-bank-cmd (sound-rpc-cmd)
|
|
((bank-name uint128 :offset-assert 16) ;; sound-name
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-test-cmd (sound-rpc-cmd)
|
|
((ee-addr pointer :offset-assert 4) ;; guessed by decompiler
|
|
(param0 uint16 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa
|
|
:flag-assert #x90000000a
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-sound-cmd (sound-rpc-cmd)
|
|
((id sound-id :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-group-cmd (sound-rpc-cmd)
|
|
((group sound-group :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-load-bank (sound-rpc-bank-cmd)
|
|
((ee-addr pointer :offset-assert 32) ;; guessed by decompiler
|
|
(mode uint32 :offset-assert 36)
|
|
(priority uint32 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-load-music (sound-rpc-bank-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-unload-bank (sound-rpc-bank-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-play (sound-rpc-sound-cmd)
|
|
((name uint128 :offset-assert 16) ;; sound-name
|
|
(params sound-play-params :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-pause-sound (sound-rpc-sound-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-stop-sound (sound-rpc-sound-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-continue-sound (sound-rpc-sound-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-param (sound-rpc-sound-cmd)
|
|
((params sound-play-params :inline :offset-assert 8)
|
|
(auto-time int32 :offset-assert 40)
|
|
(auto-from int32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-master-volume (sound-rpc-group-cmd)
|
|
((volume int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-pause-group (sound-rpc-group-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-stop-group (sound-rpc-group-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-continue-group (sound-rpc-group-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-cancel-dgo (sound-rpc-group-cmd)
|
|
((id uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-get-irx-version (sound-rpc-cmd)
|
|
((major uint32 :offset-assert 4)
|
|
(minor uint32 :offset-assert 8)
|
|
(ee-addr pointer :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-language (sound-rpc-cmd)
|
|
((lang uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-stereo-mode (sound-rpc-cmd)
|
|
((mode int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-reverb (sound-rpc-cmd)
|
|
((core uint8 :offset-assert 4)
|
|
(reverb int32 :offset-assert 8)
|
|
(left uint32 :offset-assert 12)
|
|
(right uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-ear-trans (sound-rpc-cmd)
|
|
((ear-trans1 int32 3 :offset-assert 4) ;; guessed by decompiler
|
|
(ear-trans0 int32 3 :offset-assert 16) ;; guessed by decompiler
|
|
(cam-trans int32 3 :offset-assert 28) ;; guessed by decompiler
|
|
(cam-forward UNKNOWN 3 :offset-assert 40)
|
|
(cam-left UNKNOWN 3 :offset-assert 52)
|
|
(cam-scale int32 :offset-assert 64)
|
|
(cam-inverted int32 :offset-assert 68)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-flava (sound-rpc-cmd)
|
|
((flava uint8 :offset-assert 4)
|
|
(excitement uint8 :offset-assert 5)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-midi-reg (sound-rpc-cmd)
|
|
((reg int32 :offset-assert 4)
|
|
(value int16 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa
|
|
:flag-assert #x90000000a
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-shutdown (sound-rpc-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-set-fps (sound-rpc-cmd)
|
|
((fps uint8 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5
|
|
:flag-assert #x900000005
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-list-sounds (sound-rpc-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-unload-music (sound-rpc-cmd)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-rpc-union (structure)
|
|
((data uint32 20 :offset-assert 0) ;; guessed by decompiler
|
|
(load-bank sound-rpc-load-bank :offset-assert 0)
|
|
(unload-bank sound-rpc-unload-bank :offset-assert 0)
|
|
(play sound-rpc-play :offset-assert 0)
|
|
(pause-sound sound-rpc-pause-sound :offset-assert 0)
|
|
(stop-sound sound-rpc-stop-sound :offset-assert 0)
|
|
(continue-sound sound-rpc-continue-sound :offset-assert 0)
|
|
(set-param sound-rpc-set-param :offset-assert 0)
|
|
(set-master-volume sound-rpc-set-master-volume :offset-assert 0)
|
|
(pause-group sound-rpc-pause-group :offset-assert 0)
|
|
(stop-group sound-rpc-stop-group :offset-assert 0)
|
|
(continue-group sound-rpc-continue-group :offset-assert 0)
|
|
(get-irx-version sound-rpc-get-irx-version :offset-assert 0)
|
|
(set-language sound-rpc-set-language :offset-assert 0)
|
|
(set-reverb sound-rpc-set-reverb :offset-assert 0)
|
|
(set-ear-trans sound-rpc-set-ear-trans :offset-assert 0)
|
|
(set-flava sound-rpc-set-flava :offset-assert 0)
|
|
(set-midi-reg sound-rpc-set-midi-reg :offset-assert 0)
|
|
(set-fps sound-rpc-set-fps :offset-assert 0)
|
|
(shutdown sound-rpc-shutdown :offset-assert 0)
|
|
(list-sounds sound-rpc-list-sounds :offset-assert 0)
|
|
(unload-music sound-rpc-unload-music :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-spec (basic)
|
|
((mask uint16 :offset-assert 4) ;; sound-mask
|
|
(num float :offset-assert 8)
|
|
(group uint8 :offset-assert 12) ;; sound-group
|
|
(reg uint8 3 :offset-assert 13) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(sound-name uint128 :offset-assert 16) ;; sound-name
|
|
(trans int32 4 :offset-assert 32) ;; guessed by decompiler
|
|
(volume int32 :offset-assert 48)
|
|
(pitch-mod int32 :offset-assert 52)
|
|
(bend int32 :offset-assert 56)
|
|
(fo-min int16 :offset-assert 60)
|
|
(fo-max int16 :offset-assert 62)
|
|
(fo-curve int8 :offset-assert 64)
|
|
(priority int8 :offset-assert 65)
|
|
(auto-time int32 :offset-assert 68)
|
|
(auto-from int32 :offset-assert 72)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-bank-state (structure)
|
|
((name basic :offset-assert 0)
|
|
(mode uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ambient-sound (basic)
|
|
((spec sound-spec :offset-assert 4) ;; guessed by decompiler
|
|
(playing-id sound-id :offset-assert 8) ;; guessed by decompiler
|
|
(trans vector :inline :offset-assert 16)
|
|
(name uint128 :offset-assert 32) ;; sound-name
|
|
(play-time uint64 :offset-assert 48) ;; time-frame
|
|
(time-base uint64 :offset-assert 56) ;; time-frame
|
|
(time-random uint64 :offset-assert 64) ;; time-frame
|
|
(volume int32 :offset-assert 72)
|
|
(pitch int32 :offset-assert 76)
|
|
(falloff-near int32 :offset-assert 80)
|
|
(falloff-far int32 :offset-assert 84)
|
|
(falloff-mode int32 :offset-assert 88)
|
|
(params (pointer float) :offset-assert 92) ;; guessed by decompiler
|
|
(param-count int32 :offset-assert 96)
|
|
(entity entity :offset-assert 100) ;; guessed by decompiler
|
|
(sound-count int32 :offset-assert 104)
|
|
(sound-state int32 :offset-assert 108)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x70
|
|
:flag-assert #x1100000070
|
|
(:methods
|
|
;; (new (symbol type basic vector) _type_ 0)
|
|
(ambient-sound-method-9 () none) ;; 9 ;; (update! (_type_) int 9)
|
|
(ambient-sound-method-10 () none) ;; 10 ;; (change-sound! (_type_ sound-name) int 10)
|
|
(ambient-sound-method-11 () none) ;; 11 ;; (update-trans! (_type_ vector) int 11)
|
|
(ambient-sound-method-12 () none) ;; 12 ;; (update-vol! (_type_ float) int 12)
|
|
(ambient-sound-method-13 () none) ;; 13 ;; (update-pitch-mod! (_type_ float) none 13)
|
|
(ambient-sound-method-14 () none) ;; 14 ;; (set-falloff-far! (_type_ float) none 14)
|
|
(ambient-sound-method-15 () none) ;; 15 ;; (stop! (_type_) int 15)
|
|
(ambient-sound-method-16 () none) ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *current-sound-id* object) ;; sound-id
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desbeast-path-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype desbeast-node (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(nav-mesh-id uint32 :offset-assert 16)
|
|
(pos-x float :offset-assert 0)
|
|
(pos-y float :offset-assert 4)
|
|
(pos-z float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desbeast-path (structure)
|
|
((node-count uint16 :offset-assert 0)
|
|
(node uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; texture-anim-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype texture-anim-layer (structure)
|
|
((extra vector :inline :offset-assert 240)
|
|
(func (function dma-buffer uint int int texture-anim-layer float int) :offset-assert 256) ;; guessed by decompiler
|
|
(func-id symbol :offset-assert 256) ;; guessed by decompiler
|
|
(init-func (function texture-anim-layer int) :offset-assert 260) ;; guessed by decompiler
|
|
(init-func-id symbol :offset-assert 260) ;; guessed by decompiler
|
|
(tex texture :offset-assert 264) ;; guessed by decompiler
|
|
(start-time float :offset-assert 268)
|
|
(end-time float :offset-assert 272)
|
|
(tex-name string :offset-assert 276) ;; guessed by decompiler
|
|
(test uint64 :offset-assert 280) ;; gs-test
|
|
(alpha uint64 :offset-assert 288) ;; gs-alpha
|
|
(clamp uint64 :offset-assert 296) ;; gs-clamp
|
|
(start-color vector :inline :offset-assert 80)
|
|
(start-scale vector2 :inline :offset-assert 96)
|
|
(start-offset vector2 :inline :offset-assert 104)
|
|
(start-st-scale vector2 :inline :offset-assert 112)
|
|
(start-st-offset vector2 :inline :offset-assert 120)
|
|
(start-qs vector :inline :offset-assert 128)
|
|
(start-rot deg :offset-assert 144) ;; degrees
|
|
(start-st-rot deg :offset-assert 148) ;; degrees
|
|
(end-color vector :inline :offset-assert 160)
|
|
(end-scale vector2 :inline :offset-assert 176)
|
|
(end-offset vector2 :inline :offset-assert 184)
|
|
(end-st-scale vector2 :inline :offset-assert 192)
|
|
(end-st-offset vector2 :inline :offset-assert 200)
|
|
(end-qs vector :inline :offset-assert 208)
|
|
(end-rot deg :offset-assert 224) ;; degrees
|
|
(end-st-rot deg :offset-assert 228) ;; degrees
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x130
|
|
:flag-assert #xb00000130
|
|
(:methods
|
|
(texture-anim-layer-method-9 () none) ;; 9 ;; (initialize-texture! (_type_) _type_ 9)
|
|
(texture-anim-layer-method-10 () none) ;; 10 ;; (clear-texture! (_type_) _type_ 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-anim (structure)
|
|
((num-layers uint32 :offset-assert 0)
|
|
(func (function dma-buffer texture-anim int) :offset-assert 4) ;; guessed by decompiler
|
|
(func-id symbol :offset-assert 4) ;; guessed by decompiler
|
|
(init-func (function texture-anim int) :offset-assert 8) ;; guessed by decompiler
|
|
(init-func-id symbol :offset-assert 8) ;; guessed by decompiler
|
|
(tex texture :offset-assert 12) ;; guessed by decompiler
|
|
(tex-name string :offset-assert 16) ;; guessed by decompiler
|
|
(extra vector :inline :offset-assert 32)
|
|
(color rgba :offset-assert 48) ;; guessed by decompiler
|
|
(frame-time float :offset-assert 52)
|
|
(frame-delta float :offset-assert 56)
|
|
(frame-mod float :offset-assert 60)
|
|
(test uint64 :offset-assert 64) ;; gs-test
|
|
(alpha uint64 :offset-assert 72) ;; gs-alpha
|
|
(clamp uint64 :offset-assert 80) ;; gs-clamp
|
|
(data texture-anim-layer :dynamic :offset-assert 88) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x58
|
|
:flag-assert #xb00000058
|
|
(:methods
|
|
(texture-anim-method-9 () none) ;; 9 ;; (init-textures! (_type_) _type_ 9)
|
|
(texture-anim-method-10 () none) ;; 10 ;; (clear-textures! (_type_) _type_ 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-anim-array (array)
|
|
((type type :offset-assert 0) ;; guessed by decompiler
|
|
(length int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
(content-type type :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x10
|
|
:flag-assert #xb00000010
|
|
(:methods
|
|
(texture-anim-array-method-9 () none) ;; 9 ;; (init! (_type_) _type_ 9)
|
|
(texture-anim-array-method-10 () none) ;; 10 ;; (clear! (_type_) _type_ 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-anim-work (structure)
|
|
((erase-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(draw-tmpl dma-gif-packet :inline :offset-assert 32)
|
|
(draw2-tmpl dma-gif-packet :inline :offset-assert 64)
|
|
(fill-tmpl dma-gif-packet :inline :offset-assert 96)
|
|
(adgif-tmpl dma-gif-packet :inline :offset-assert 128)
|
|
(corner0 vector :inline :offset-assert 160)
|
|
(corner1 vector :inline :offset-assert 176)
|
|
(corner2 vector :inline :offset-assert 192)
|
|
(corner3 vector :inline :offset-assert 208)
|
|
(const vector :inline :offset-assert 224)
|
|
(color vector4w :inline :offset-assert 240)
|
|
(random vector4w 8 :offset-assert 256) ;; guessed by decompiler
|
|
(random-index uint8 :offset-assert 384)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x181
|
|
:flag-assert #x900000181
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clut16x16 (structure)
|
|
((clut rgba 256 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x400
|
|
:flag-assert #x900000400
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype noise8x8 (structure)
|
|
((image uint8 64 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype noise16x16 (structure)
|
|
((image uint8 256 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x100
|
|
:flag-assert #x900000100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype noise32x32 (structure)
|
|
((image uint8 1024 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x400
|
|
:flag-assert #x900000400
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype noise64x64 (structure)
|
|
((image uint8 4096 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1000
|
|
:flag-assert #x900001000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype noise128x128 (structure)
|
|
((image uint8 16384 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4000
|
|
:flag-assert #x900004000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fog8x256 (structure)
|
|
((image uint8 256 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x100
|
|
:flag-assert #x900000100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fog-texture-work (structure)
|
|
((corner vector 4 :offset-assert 0) ;; guessed by decompiler
|
|
(const vector :inline :offset-assert 64)
|
|
(min-corner vector :inline :offset-assert 80)
|
|
(max-corner vector :inline :offset-assert 96)
|
|
(fog-near float :offset-assert 112)
|
|
(fog-far float :offset-assert 116)
|
|
(fog-delta float :offset-assert 120)
|
|
(alpha-near float :offset-assert 124)
|
|
(alpha-far float :offset-assert 128)
|
|
(alpha-delta float :offset-assert 132)
|
|
(color uint32 :offset-assert 136)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8c
|
|
:flag-assert #x90000008c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *clut-translate* object) ;; (pointer uint8)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; history ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype history-elt (structure)
|
|
((record-tag-bytes uint8 4 :offset-assert 0) ;; guessed by decompiler
|
|
(record-tag uint32 :offset-assert 0)
|
|
(record-id uint16 :offset-assert 0)
|
|
(owner uint8 :offset-assert 2)
|
|
(channel uint8 :offset-assert 4) ;; history-channel
|
|
(timestamp uint64 :offset-assert 8) ;; time-frame
|
|
(origin vector :inline :offset-assert 16)
|
|
(bytes uint8 16 :offset-assert 32) ;; guessed by decompiler
|
|
(vector vector :inline :offset-assert 32)
|
|
(float float :offset-assert 32)
|
|
(collide-status uint64 :offset-assert 32) ;; collide-status
|
|
(collide-reaction-flag uint32 :offset-assert 40)
|
|
(pat pat-surface :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype history-iterator (basic)
|
|
((max-age uint32 :offset-assert 4)
|
|
(owner uint8 :offset-assert 8)
|
|
(proc process :offset-assert 12) ;; guessed by decompiler
|
|
(out object :offset-assert 16) ;; guessed by decompiler
|
|
(channel-mask uint64 :offset-assert 24)
|
|
(index int32 :offset-assert 32)
|
|
(done? symbol :offset-assert 36) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x28
|
|
:flag-assert #xc00000028
|
|
;; field out uses ~A with a signed load.
|
|
(:methods
|
|
;; (new (symbol type uint) _type_ 0)
|
|
(history-iterator-method-9 () none) ;; 9 ;; (frame-counter-delta (_type_ history-elt) time-frame 9)
|
|
(history-iterator-method-10 () none) ;; 10 ;; (update-entries! (_type_) history-elt 10)
|
|
(history-iterator-method-11 () none) ;; 11 ;; (get-age (_type_ history-elt) float 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype history (basic)
|
|
((alloc-index int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
(elts history-elt :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x10
|
|
:flag-assert #xb00000010
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(history-method-9 () none) ;; 9 ;; (clear-record-tags! (_type_ history-channel uint uint) history-elt 9)
|
|
(history-method-10 () none) ;; 10 ;; (clear-history-entries! (_type_) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern history-channel->string function) ;; (function history-channel string)
|
|
;; (define-extern *history* object) ;; history
|
|
;; (define-extern history-print function) ;; (function history-iterator none)
|
|
;; (define-extern history-draw function) ;; (function history-iterator none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; process-drawable ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cspace-by-name function) ;; (function process-drawable string cspace)
|
|
;; (define-extern cspace-index-by-name function) ;; (function process-drawable string int)
|
|
;; (define-extern vector<-cspace! function) ;; (function vector cspace vector)
|
|
;; (define-extern vector<-matrix! function) ;; (function vector matrix vector)
|
|
;; (define-extern vector<-cspace+vector! function) ;; (function vector cspace vector vector)
|
|
;; (define-extern cspace-children function) ;; (function process-drawable int pair)
|
|
;; (define-extern cspace-inspect-tree function) ;; (function process-drawable cspace int int object process-drawable)
|
|
;; (define-extern execute-math-engine function) ;; (function int)
|
|
;; (define-extern execute-cloth-engine function)
|
|
;; (define-extern draw-joint-axes function) ;; (function process-drawable none)
|
|
;; (define-extern draw-root function) ;; (function process-drawable none)
|
|
;; (define-extern empty-state state) ;; (state process)
|
|
;; (define-extern process-drawable-error-print function)
|
|
;; (define-extern skeleton-group->draw-control function) ;; (function process-drawable skeleton-group (pointer cspace-array) draw-control)
|
|
;; (define-extern ja-group-in-array? function)
|
|
;; (define-extern ja-done? function) ;; (function int symbol :behavior process-drawable)
|
|
;; (define-extern ja-min? function) ;; (function int symbol :behavior process-drawable)
|
|
;; (define-extern ja-max? function) ;; (function int symbol :behavior process-drawable)
|
|
;; (define-extern ja-num-frames function) ;; (function int int :behavior process-drawable)
|
|
;; (define-extern ja-frame-num function) ;; (function int float :behavior process-drawable)
|
|
;; (define-extern ja-aframe-num function) ;; (function int float :behavior process-drawable)
|
|
;; (define-extern ja-aframe function) ;; (function float int float :behavior process-drawable)
|
|
;; (define-extern ja-speed function) ;; (function int float :behavior process-drawable)
|
|
;; (define-extern ja-step function) ;; (function int float :behavior process-drawable)
|
|
;; (define-extern ja-rate function)
|
|
;; (define-extern ja-linear-vel function)
|
|
;; (define-extern ja-channel-set! function) ;; (function int int :behavior process-drawable)
|
|
;; (define-extern ja-channel-push! function) ;; (function int time-frame int :behavior process-drawable)
|
|
;; (define-extern ja-channel-float! function) ;; (function art-joint-anim float float float joint-control-channel :behavior process-drawable)
|
|
;; (define-extern joint-control-reset! function) ;; (function joint-control joint-control-channel none :behavior process-drawable)
|
|
;; (define-extern ja-group-size function) ;; (function int :behavior process-drawable)
|
|
;; (define-extern ja-eval function) ;; (function int :behavior process-drawable)
|
|
;; (define-extern ja-blend-eval function) ;; (function int :behavior process-drawable)
|
|
;; (define-extern cloth-post function)
|
|
;; (define-extern ja-post function) ;; (function none :behavior process-drawable)
|
|
;; (define-extern sleep-code function) ;; (function symbol :behavior process)
|
|
;; (define-extern transform-and-sleep function) ;; (function none :behavior process-drawable)
|
|
;; (define-extern transform-and-sleep-code function) ;; (function none :behavior process-drawable)
|
|
;; (define-extern transform-post function) ;; (function int :behavior process-drawable)
|
|
;; (define-extern rider-trans function) ;; (function none :behavior process-drawable)
|
|
;; (define-extern rider-post function) ;; (function none :behavior process-drawable)
|
|
;; (define-extern pusher-post function) ;; (function int :behavior process-drawable)
|
|
;; (define-extern process-drawable-delay-player function) ;; (function time-frame int :behavior process-drawable)
|
|
;; (define-extern process-drawable-fuel-cell-handler function) ;; (function process int symbol event-message-block none :behavior process-drawable)
|
|
;; (define-extern process-drawable-birth-fuel-cell function) ;; (function entity vector symbol none :behavior process-drawable)
|
|
;; (define-extern find-offending-process-focusable function) ;; (function process-tree attack-info process-focusable :behavior process-drawable)
|
|
;; (define-extern *valid-con* object) ;; string
|
|
;; (define-extern process-drawable-valid? function) ;; (function process-drawable symbol)
|
|
;; (define-extern process-drawable-reset-all-cloth function)
|
|
;; (define-extern process-drawable-set-riding function)
|
|
;; (define-extern process-drawable-set-cloth-ground-height function)
|
|
;; (define-extern process-drawable-set-wind-strength function)
|
|
;; (define-extern process-drawable-show-all-cloth function)
|
|
;; (define-extern process-drawable-slow-mo-cloth function)
|
|
;; (define-extern process-drawable-cloth-command function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vif-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vif-stat (uint32)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (deftype vif-fbrst (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype vif-err (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
#|
|
|
(deftype vif-bank (structure)
|
|
((stat uint32 :offset-assert 0)
|
|
(fbrst uint32 :offset-assert 16)
|
|
(err vif-err :offset-assert 32) ;; guessed by decompiler
|
|
(mark uint32 :offset-assert 48)
|
|
(cycle uint32 :offset-assert 64)
|
|
(mode uint32 :offset-assert 80)
|
|
(num uint32 :offset-assert 96)
|
|
(mask uint32 :offset-assert 112)
|
|
(code uint32 :offset-assert 128)
|
|
(itops uint32 :offset-assert 144)
|
|
(base uint32 :offset-assert 160)
|
|
(offset uint32 :offset-assert 176)
|
|
(tops uint32 :offset-assert 192)
|
|
(itop uint32 :offset-assert 208)
|
|
(top uint32 :offset-assert 224)
|
|
(r0 uint32 :offset-assert 256)
|
|
(r1 uint32 :offset-assert 272)
|
|
(r2 uint32 :offset-assert 288)
|
|
(r3 uint32 :offset-assert 304)
|
|
(c0 uint32 :offset-assert 320)
|
|
(c1 uint32 :offset-assert 336)
|
|
(c2 uint32 :offset-assert 352)
|
|
(c3 uint32 :offset-assert 368)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x174
|
|
:flag-assert #x900000174
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; shrub-work ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *instance-shrub-work* object) ;; instance-shrub-work
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; capture-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gs-store-image-packet (structure)
|
|
((vifcode vif-tag 4 :offset-assert 0) ;; guessed by decompiler
|
|
(giftag uint128 :offset-assert 16) ;; gif-tag
|
|
(bitbltbuf uint64 :offset-assert 32) ;; gs-bitbltbuf
|
|
(bitbltbuf-addr uint64 :offset-assert 40) ;; gs-reg64
|
|
(trxpos uint64 :offset-assert 48) ;; gs-trxpos
|
|
(trxpos-addr uint64 :offset-assert 56) ;; gs-reg64
|
|
(trxreg uint64 :offset-assert 64) ;; gs-trxreg
|
|
(trxreg-addr uint64 :offset-assert 72) ;; gs-reg64
|
|
(finish uint64 :offset-assert 80) ;; int64
|
|
(finish-addr uint64 :offset-assert 88) ;; gs-reg64
|
|
(trxdir uint64 :offset-assert 96) ;; gs-trxdir
|
|
(trxdir-addr uint64 :offset-assert 104) ;; gs-reg64
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype screen-shot-work (structure)
|
|
((count int16 :offset-assert 0)
|
|
(size int16 :offset-assert 2)
|
|
(name string :offset-assert 4) ;; guessed by decompiler
|
|
(highres-enable symbol :offset-assert 8) ;; guessed by decompiler
|
|
(hud-enable symbol :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *screen-shot-work* object) ;; screen-shot-work
|
|
;; (define-extern *image-name* object) ;; string
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-effect ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *target-lock* object) ;; object
|
|
;; (define-extern *generic-consts* object) ;; generic-consts
|
|
;; (define-extern generic-work-init function) ;; (function generic-bucket-state none)
|
|
;; (define-extern generic-upload-vu0 function) ;; (function none)
|
|
;; (define-extern upload-vu0-program function) ;; (function vu-function pointer none)
|
|
;; (define-extern generic-initialize-without-sync function) ;; (function matrix vu-lights none)
|
|
;; (define-extern generic-initialize function) ;; (function generic-bucket-state matrix vu-lights none)
|
|
;; (define-extern generic-wrapup function) ;; (function generic-bucket-state none)
|
|
;; (define-extern generic-dma-from-spr function)
|
|
;; (define-extern generic-light-proc function)
|
|
;; (define-extern generic-envmap-proc function)
|
|
;; (define-extern generic-prepare-dma-double function)
|
|
;; (define-extern generic-prepare-dma-single function)
|
|
;; (define-extern generic-envmap-dproc function)
|
|
;; (define-extern generic-interp-dproc function)
|
|
;; (define-extern generic-no-light-proc function)
|
|
;; (define-extern generic-no-light-dproc-only function)
|
|
;; (define-extern generic-no-light-dproc function)
|
|
;; (define-extern generic-no-light+envmap function)
|
|
;; (define-extern generic-no-light function)
|
|
;; (define-extern generic-envmap-only-proc function)
|
|
;; (define-extern generic-light function)
|
|
;; (define-extern generic-copy-vtx-dclr-dtex function)
|
|
;; (define-extern generic-none function)
|
|
;; (define-extern generic-none-dma-wait function)
|
|
;; (define-extern *warp-data* object) ;; object
|
|
;; (define-extern generic-warp-source-proc function) ;; (function none)
|
|
;; (define-extern generic-warp-source function) ;; (function gsf-buffer none)
|
|
;; (define-extern generic-warp-dest-proc function)
|
|
;; (define-extern generic-warp-dest function)
|
|
;; (define-extern generic-warp-envmap-dest function)
|
|
;; (define-extern generic-debug-light-proc function)
|
|
;; (define-extern generic-post-debug function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dma-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dma-chcr (uint32)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-bank (structure)
|
|
((chcr dma-chcr :offset-assert 0) ;; guessed by decompiler
|
|
(madr uint32 :offset-assert 16)
|
|
(qwc uint32 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-bank-source (dma-bank)
|
|
((tadr uint32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-bank-vif (dma-bank-source)
|
|
((as0 uint32 :offset-assert 64)
|
|
(as1 uint32 :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x54
|
|
:flag-assert #x900000054
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-bank-spr (dma-bank-source)
|
|
((sadr uint32 :offset-assert 128)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x84
|
|
:flag-assert #x900000084
|
|
)
|
|
|#
|
|
|
|
;; (deftype dma-ctrl (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype dma-enable (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype dma-sqwc (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
#|
|
|
(deftype dma-bank-control (structure)
|
|
((ctrl dma-ctrl :offset-assert 0) ;; guessed by decompiler
|
|
(stat uint32 :offset-assert 16)
|
|
(pcr uint32 :offset-assert 32)
|
|
(sqwc dma-sqwc :offset-assert 48) ;; guessed by decompiler
|
|
(rbsr uint32 :offset-assert 64)
|
|
(rbor uint32 :offset-assert 80)
|
|
(stadr uint32 :offset-assert 96)
|
|
(enabler uint32 :offset-assert 5408)
|
|
(enablew uint32 :offset-assert 5520)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1594
|
|
:flag-assert #x900001594
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vu-code-block (basic)
|
|
((name basic :offset-assert 4)
|
|
(code uint32 :offset-assert 8)
|
|
(size int32 :offset-assert 12)
|
|
(dest-address uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
;; (deftype vu-stat (uint64)
|
|
;; ()
|
|
;; :flag-assert #x900000008
|
|
;; )
|
|
|
|
#|
|
|
(deftype dma-tag (uint64)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-bucket (structure)
|
|
((tag uint64 :offset-assert 0) ;; dma-tag
|
|
(last (pointer dma-tag) :offset-assert 8) ;; guessed by decompiler
|
|
(dummy uint32 :offset-assert 12)
|
|
(next uint32 :offset-assert 4)
|
|
(clear uint64 :offset-assert 8)
|
|
(vif0 uint32 :offset-assert 8)
|
|
(vif1 uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (deftype vif-mask (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
;; (deftype vif-stcycl-imm (uint16)
|
|
;; ()
|
|
;; :flag-assert #x900000002
|
|
;; )
|
|
|
|
;; (deftype vif-unpack-imm (uint16)
|
|
;; ()
|
|
;; :flag-assert #x900000002
|
|
;; )
|
|
|
|
#|
|
|
(deftype vif-tag (uint32)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern dma-sync-fast function) ;; (function dma-bank none)
|
|
;; (define-extern dma-send-no-scratch function) ;; (function dma-bank uint32 uint32 none)
|
|
;; (define-extern dma-sync-with-count function) ;; (function dma-bank (pointer int32) int)
|
|
;; (define-extern dma-count-until-done function) ;; (function dma-bank (pointer int32) int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pilot-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vehicle-controls (structure)
|
|
((steering float :offset-assert 0)
|
|
(throttle float :offset-assert 4)
|
|
(brake float :offset-assert 8)
|
|
(lean-z float :offset-assert 12)
|
|
(handbrake float :offset-assert 16)
|
|
(flags uint8 :offset-assert 20)
|
|
(prev-flags uint8 :offset-assert 21)
|
|
(pad0 UNKNOWN 2 :offset-assert 22)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pilot-info (basic)
|
|
((entity basic :offset-assert 4)
|
|
(vehicle uint64 :offset-assert 8) ;; handle
|
|
(left-right-bias float :offset-assert 16)
|
|
(left-right-min float :offset-assert 20)
|
|
(left-right-max float :offset-assert 24)
|
|
(left-right-interp float :offset-assert 28)
|
|
(front-back-interp float :offset-assert 32)
|
|
(up-down-interp float :offset-assert 36)
|
|
(up-down-accel-factor float :offset-assert 40)
|
|
(front-back-accel-factor float :offset-assert 44)
|
|
(left-right-accel-factor float :offset-assert 48)
|
|
(stance uint8 :offset-assert 52)
|
|
(seat-index int8 :offset-assert 53)
|
|
(backup-nav-radius float :offset-assert 56)
|
|
(cam-side-shift float :offset-assert 60)
|
|
(enable-cam-side-shift symbol :offset-assert 64) ;; guessed by decompiler
|
|
(gun? symbol :offset-assert 68) ;; guessed by decompiler
|
|
(controls vehicle-controls :inline :offset-assert 72)
|
|
(accel-array vector :inline :offset-assert 96)
|
|
(local-accel vector :inline :offset-assert 224)
|
|
(pilot-trans vector :inline :offset-assert 240)
|
|
(pilot-quat vector :inline :offset-assert 256)
|
|
(pilot-scale vector :inline :offset-assert 272)
|
|
(underwater-time uint64 :offset-assert 288)
|
|
(as-daxter? symbol :offset-assert 296) ;; guessed by decompiler
|
|
(art-group-backup basic :offset-assert 300)
|
|
(hud-health uint64 :offset-assert 304)
|
|
(hud-turbo uint64 :offset-assert 312)
|
|
(jumping? basic :offset-assert 320)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x144
|
|
:flag-assert #x900000144
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; stats-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tr-stat (structure)
|
|
((groups uint16 :offset-assert 0)
|
|
(fragments uint16 :offset-assert 2)
|
|
(tris uint32 :offset-assert 4)
|
|
(dverts uint32 :offset-assert 8)
|
|
(instances uint16 :offset-assert 12)
|
|
(pad uint16 :offset-assert 14)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-global-stats (structure)
|
|
((merc tr-stat :inline :offset-assert 0)
|
|
(emerc tr-stat :inline :offset-assert 16)
|
|
(mercneric tr-stat :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype perf-stat (structure)
|
|
((frame-number uint32 :offset-assert 0)
|
|
(count uint32 :offset-assert 4)
|
|
(cycles uint32 :offset-assert 8)
|
|
(instructions uint32 :offset-assert 12)
|
|
(icache uint32 :offset-assert 16)
|
|
(dcache uint32 :offset-assert 20)
|
|
(select uint32 :offset-assert 24)
|
|
(ctrl uint32 :offset-assert 28)
|
|
(accum0 uint32 :offset-assert 32)
|
|
(accum1 uint32 :offset-assert 36)
|
|
(to-vu0-waits uint32 :offset-assert 40)
|
|
(to-spr-waits uint32 :offset-assert 44)
|
|
(from-spr-waits uint32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x34
|
|
:flag-assert #xe00000034
|
|
(:methods
|
|
(perf-stat-method-9 () none) ;; 9 ;; (perf-stat-method-9 () none 9)
|
|
(perf-stat-method-10 () none) ;; 10 ;; (print-to-stream (_type_ string basic) none 10)
|
|
(perf-stat-method-11 () none) ;; 11 ;; (reset! (_type_) none 11)
|
|
(perf-stat-method-12 () none) ;; 12 ;; (read! (_type_) none 12)
|
|
(perf-stat-method-13 () none) ;; 13 ;; (update-wait-stats (_type_ uint uint uint) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype perf-stat-array (inline-array-class)
|
|
((data perf-stat :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern perf-stat-bucket->string function) ;; (function perf-stat-bucket string)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; video-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype video-params (structure)
|
|
((set-video-mode symbol :offset-assert 0) ;; guessed by decompiler
|
|
(reset-video-mode symbol :offset-assert 4) ;; guessed by decompiler
|
|
(display-fbp int32 :offset-assert 8)
|
|
(relative-x-scale float :offset-assert 16)
|
|
(display-dx int32 :offset-assert 20)
|
|
(display-dy int32 :offset-assert 24)
|
|
(display-sy int32 :offset-assert 28)
|
|
(relative-x-scale-reciprical float :offset-assert 32)
|
|
(screen-pages-high int32 :offset-assert 36)
|
|
(smode2 uint64 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *video-params* object) ;; video-params
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-boss-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype factory-boss-command (structure)
|
|
((action uint64 :offset-assert 0)
|
|
(suck float :offset-assert 8)
|
|
(random float :offset-assert 12)
|
|
(round int8 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x11
|
|
:flag-assert #x900000011
|
|
)
|
|
|#
|
|
|
|
;; (define-extern factory-boss-angle-sub function)
|
|
;; (define-extern factory-boss-target-pos function)
|
|
;; (define-extern factory-boss-move function)
|
|
;; (define-extern factory-boss-pick-machine function)
|
|
;; (define-extern factory-boss-pick-camera function)
|
|
;; (define-extern factory-boss-pick-pers-camera function)
|
|
;; (define-extern factory-boss-machine-angle function)
|
|
;; (define-extern factory-boss-approaching? function)
|
|
;; (define-extern factory-boss-move-to-dest-angle function)
|
|
;; (define-extern factory-boss-time-until-angle function)
|
|
;; (define-extern factory-boss-get-particle-spawn-points function)
|
|
;; (define-extern factory-boss-drop-bomb function)
|
|
;; (define-extern factory-boss-check-bomb-timer function)
|
|
;; (define-extern factory-boss-end-cutscene function)
|
|
;; (define-extern factory-boss-spawn-ring function)
|
|
;; (define-extern factory-boss-always function)
|
|
;; (define-extern factory-boss-always-handler function)
|
|
;; (define-extern factory-boss-handler function)
|
|
;; (define-extern *factory-boss-swarm-0* array)
|
|
;; (define-extern *factory-boss-swarm-1* array)
|
|
;; (define-extern *factory-boss-swarm-2* array)
|
|
;; (define-extern *factory-boss-swarm-3* array)
|
|
;; (define-extern *factory-boss-swarm-4* array)
|
|
;; (define-extern factory-boss-launch-critter-handler function)
|
|
;; (define-extern factory-boss-advance-launch-script function)
|
|
;; (define-extern factory-boss-check-launch-script function)
|
|
;; (define-extern factory-boss-launch-critter function)
|
|
;; (define-extern factory-boss-launch-critter-pick-anim function)
|
|
;; (define-extern factory-boss-pick-floor-targets function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dma-buffer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dma-packet (structure)
|
|
((dma uint64 :offset-assert 0) ;; dma-tag
|
|
(vif0 vif-tag :offset-assert 8) ;; guessed by decompiler
|
|
(vif1 vif-tag :offset-assert 12) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-packet-array (inline-array-class)
|
|
((data dma-packet :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-gif (structure)
|
|
((gif uint64 2 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-gif-packet (structure)
|
|
((dma-vif dma-packet :inline :offset-assert 0)
|
|
(gif uint64 2 :offset-assert 16) ;; guessed by decompiler
|
|
(quad uint128 2 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-buffer (basic)
|
|
((allocated-length int32 :offset-assert 4)
|
|
(base pointer :offset-assert 8) ;; guessed by decompiler
|
|
(end pointer :offset-assert 12) ;; guessed by decompiler
|
|
(real-buffer-end int32 :offset-assert 16)
|
|
(data uint64 1 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
;; (define-extern dma-buffer-inplace-new function) ;; (function dma-buffer int dma-buffer)
|
|
;; (define-extern dma-buffer-length function) ;; (function dma-buffer int)
|
|
;; (define-extern dma-buffer-free function) ;; (function dma-buffer int)
|
|
;; (define-extern dma-buffer-add-vu-function function) ;; (function dma-buffer vu-function int symbol)
|
|
;; (define-extern dma-buffer-send function) ;; (function dma-bank dma-buffer none)
|
|
;; (define-extern dma-buffer-send-chain function) ;; (function dma-bank-source dma-buffer none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; forest-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-birth-func-brightness-part-neo-spawner-explode-juice function)
|
|
;; (define-extern spt-birth-func-brightness-part-forest-leaf-fall function)
|
|
;; (define-extern spt-birth-func-part-forest-leaf-fall function)
|
|
;; (define-extern spt-forest-check-ground-lie-flat function)
|
|
;; (define-extern spt-birth-func-part-forest-leaf-fall-water function)
|
|
;; (define-extern spt-check-water-lie-flat function)
|
|
;; (define-extern spt-birth-func-brightness-mh-plant-rebirth-dust function)
|
|
;; (define-extern spt-birth-func-brightness-mh-plant-rebirth-rocks function)
|
|
;; (define-extern spt-birth-func-brightness-mh-plant-rebirth-dirt function)
|
|
;; (define-extern spt-birth-func-part-mh-plant-rebirth-dirt function)
|
|
;; (define-extern spt-birth-func-part-mh-plant-rebirth-rocks function)
|
|
;; (define-extern spt-func-part-mh-plant-rebirth-rocks function)
|
|
;; (define-extern spt-func-birth-on-stop function)
|
|
;; (define-extern spt-birth-func-brightness-mh-plant-die-juice function)
|
|
;; (define-extern spt-birth-func-brightness-for-bridge-bits function)
|
|
;; (define-extern spt-birth-func-part-for-bridge-bits function)
|
|
;; (define-extern *range-ffexplo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-ffexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-for-ring-finder-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-ffexplo-color* curve-color-fast)
|
|
;; (define-extern *range-ffexplo-alpha* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-for-ring-finder-explosion-texture-curve-settings* object)
|
|
;; (define-extern birth-func-for-ground-dirt-bounce function)
|
|
;; (define-extern spt-func-for-ground-dirt-bounce1 function)
|
|
;; (define-extern spt-func-for-ground-dirt-bounce2 function)
|
|
;; (define-extern spt-birth-func-brightness-for-statue-rocks function)
|
|
;; (define-extern spt-birth-func-brightness-for-statue-dirt function)
|
|
;; (define-extern spt-birth-func-part-for-statue-rise-dirt function)
|
|
;; (define-extern spt-birth-func-part-for-statue-rise-rocks function)
|
|
;; (define-extern spt-func-part-for-statue-rise-rocks function)
|
|
;; (define-extern spt-birth-func-part-for-statue-rise-rocks-bounce1 function)
|
|
;; (define-extern spt-func-part-for-statue-rise-rocks-bounce1 function)
|
|
;; (define-extern spt-func-for-ground-dirt-bounce3 function)
|
|
;; (define-extern spt-birth-func-part-for-statue-rise-rocks-bounce2 function)
|
|
;; (define-extern *range-sat-explo-color* curve-color-fast)
|
|
;; (define-extern *range-sat-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-sat-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-sat-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-for-statue-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pilot-recorder ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pilrec-sample (structure)
|
|
((sample-time uint64 :offset-assert 0) ;; time-frame
|
|
(pos vector :inline :offset-assert 16)
|
|
(quat quaternion :inline :offset-assert 32)
|
|
(stick-x float :offset-assert 48)
|
|
(stick-y float :offset-assert 52)
|
|
(throttle float :offset-assert 56)
|
|
(flags uint8 :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3d
|
|
:flag-assert #x90000003d
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pilot-recorder-samples (basic)
|
|
((samples (inline-array pilrec-sample) :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pilot-recorder (process)
|
|
((info race-info :offset-assert 128) ;; guessed by decompiler
|
|
(mesh race-mesh :offset-assert 132) ;; guessed by decompiler
|
|
(select-race uint64 :offset-assert 136)
|
|
(path-num int32 :offset-assert 144)
|
|
(sample-count int32 :offset-assert 148)
|
|
(samples pilot-recorder-samples :offset-assert 152) ;; guessed by decompiler
|
|
(state-time uint64 :offset-assert 160) ;; time-frame
|
|
(start-time uint64 :offset-assert 168) ;; time-frame
|
|
(start-record-plane plane :inline :offset-assert 176)
|
|
(start-record-center vector :inline :offset-assert 192)
|
|
(finish-record-plane plane :inline :offset-assert 208)
|
|
(finish-record-center vector :inline :offset-assert 224)
|
|
(prev-pos vector :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #x100
|
|
:flag-assert #x1f00800100
|
|
(:methods
|
|
(pilot-recorder-method-22 () none) ;; 22 ;; (pilot-recorder-method-22 () none 22)
|
|
(pilot-recorder-method-23 () none) ;; 23 ;; (pilot-recorder-method-23 () none 23)
|
|
(pilot-recorder-method-24 () none) ;; 24 ;; (pilot-recorder-method-24 () none 24)
|
|
(pilot-recorder-method-25 () none) ;; 25 ;; (pilot-recorder-method-25 () none 25)
|
|
(pilot-recorder-method-26 () none) ;; 26 ;; (pilot-recorder-method-26 () none 26)
|
|
(pilot-recorder-method-27 () none) ;; 27 ;; (pilot-recorder-method-27 () none 27)
|
|
(pilot-recorder-method-28 () none) ;; 28 ;; (pilot-recorder-method-28 () none 28)
|
|
(pilot-recorder-method-29 () none) ;; 29 ;; (pilot-recorder-method-29 () none 29)
|
|
(pilot-recorder-method-30 () none) ;; 30 ;; (pilot-recorder-method-30 () none 30)
|
|
)
|
|
(:state-methods
|
|
idle ;; 15, old: (idle () _type_ :state 15)
|
|
active ;; 16, old: (active () _type_ :state 16)
|
|
recording ;; 17, old: (recording () _type_ :state 17)
|
|
finished ;; 19, old: (finished () _type_ :state 19)
|
|
save ;; 20, old: (save () _type_ :state 20)
|
|
fail-save ;; 21, old: (fail-save () _type_ :state 21)
|
|
fail-full ;; 18, old: (fail-full () _type_ :state 18)
|
|
die-fast ;; 14, old: (die-fast () _type_ :state 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *pilot-recorder-samples* object)
|
|
;; (define-extern delete-race-path function)
|
|
;; (define-extern *pilot-recorder* object)
|
|
;; (define-extern pilot-recorder-init-by-other function)
|
|
;; (define-extern start-pilot-recorder function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pad ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype scf-time (structure)
|
|
((stat uint8 :offset-assert 0)
|
|
(second uint8 :offset-assert 1)
|
|
(minute uint8 :offset-assert 2)
|
|
(hour uint8 :offset-assert 3)
|
|
(week uint8 :offset-assert 4)
|
|
(day uint8 :offset-assert 5)
|
|
(month uint8 :offset-assert 6)
|
|
(year uint8 :offset-assert 7)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hw-cpad (basic)
|
|
((valid uint8 :offset-assert 4)
|
|
(status uint8 :offset-assert 5)
|
|
(button0 uint16 :offset-assert 6)
|
|
(rightx uint8 :offset-assert 8)
|
|
(righty uint8 :offset-assert 9)
|
|
(leftx uint8 :offset-assert 10)
|
|
(lefty uint8 :offset-assert 11)
|
|
(abutton uint8 12 :offset-assert 12) ;; guessed by decompiler
|
|
(dummy uint8 12 :offset-assert 24) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cpad-info (hw-cpad)
|
|
((number int32 :offset-assert 36)
|
|
(cpad-file int32 :offset-assert 40)
|
|
(button0-abs pad-buttons 3 :offset-assert 44) ;; guessed by decompiler
|
|
(button0-shadow-abs pad-buttons 1 :offset-assert 56) ;; guessed by decompiler
|
|
(button0-rel pad-buttons 3 :offset-assert 60) ;; guessed by decompiler
|
|
(stick0-dir float :offset-assert 72)
|
|
(stick0-speed float :offset-assert 76)
|
|
(new-pad int32 :offset-assert 80)
|
|
(state int32 :offset-assert 84)
|
|
(align uint8 6 :offset-assert 88) ;; guessed by decompiler
|
|
(direct uint8 6 :offset-assert 94) ;; guessed by decompiler
|
|
(buzz-val uint8 2 :offset-assert 100) ;; guessed by decompiler
|
|
(buzz-pause-val uint8 1 :offset-assert 102) ;; guessed by decompiler
|
|
(buzz-pause-time uint8 :offset-assert 103)
|
|
(buzz-time time-frame 2 :offset-assert 104) ;; guessed by decompiler
|
|
(buzz basic :offset-assert 120)
|
|
(buzz-act int32 :offset-assert 124)
|
|
(change-time uint64 :offset-assert 128) ;; time-frame
|
|
(real-change-time uint64 :offset-assert 136)
|
|
(old-rightx uint8 2 :offset-assert 144) ;; guessed by decompiler
|
|
(old-righty uint8 2 :offset-assert 146) ;; guessed by decompiler
|
|
(old-leftx uint8 2 :offset-assert 148) ;; guessed by decompiler
|
|
(old-lefty uint8 2 :offset-assert 150) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x98
|
|
:flag-assert #xa00000098
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(cpad-info-method-9 () none) ;; 9 ;; (adjust-to-screen-flip (_type_) int 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cpad-list (basic)
|
|
((num-cpads int32 :offset-assert 4)
|
|
(cpads cpad-info 2 :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mouse-info (basic)
|
|
((active symbol :offset-assert 4) ;; guessed by decompiler
|
|
(cursor basic :offset-assert 8)
|
|
(valid symbol :offset-assert 12) ;; guessed by decompiler
|
|
(id uint8 :offset-assert 16)
|
|
(status uint16 :offset-assert 18)
|
|
(button0 uint16 :offset-assert 20)
|
|
(deltax int8 :offset-assert 22)
|
|
(deltay int8 :offset-assert 23)
|
|
(wheel uint8 :offset-assert 24)
|
|
(change-time uint64 :offset-assert 32) ;; time-frame
|
|
(button0-abs mouse-buttons 3 :offset-assert 40) ;; guessed by decompiler
|
|
(button0-shadow-abs mouse-buttons 1 :offset-assert 52) ;; guessed by decompiler
|
|
(button0-rel mouse-buttons 3 :offset-assert 56) ;; guessed by decompiler
|
|
(pos vector 2 :offset-assert 80) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(posx float :offset-assert 80)
|
|
(posy float :offset-assert 84)
|
|
(oldposx float :offset-assert 96)
|
|
(oldposy float :offset-assert 100)
|
|
(speedx float :offset-assert 92)
|
|
(speedy float :offset-assert 108)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype keybd-info (basic)
|
|
((active basic :offset-assert 4)
|
|
(valid basic :offset-assert 8)
|
|
(kdata UNKNOWN 16 :offset-assert 12)
|
|
(keys UNKNOWN 256 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x11c
|
|
:flag-assert #x90000011c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *cheat-mode* object) ;; symbol
|
|
;; (define-extern cpad-invalid! function) ;; (function cpad-info cpad-info)
|
|
;; (define-extern analog-input function) ;; (function int float float float float float)
|
|
;; (define-extern cpad-set-buzz! function) ;; (function cpad-info int int time-frame none)
|
|
;; (define-extern *cpad-list* object) ;; cpad-list
|
|
;; (define-extern *cpad-debug* object) ;; symbol
|
|
;; (define-extern service-cpads function) ;; (function cpad-list)
|
|
;; (define-extern buzz-stop! function) ;; (function int none)
|
|
;; (define-extern *mouse* object) ;; mouse-info
|
|
;; (define-extern service-mouse function) ;; (function none)
|
|
;; (define-extern *keybd* object)
|
|
;; (define-extern service-keybd function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; display-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype display-frame (basic)
|
|
((buffer dma-buffer 11 :offset-assert 4) ;; guessed by decompiler
|
|
(calc-buf dma-buffer :offset-assert 8) ;; guessed by decompiler
|
|
(vu1-buf dma-buffer :offset-assert 8) ;; guessed by decompiler
|
|
(debug-buf dma-buffer :offset-assert 36) ;; guessed by decompiler
|
|
(global-buf dma-buffer :offset-assert 40) ;; guessed by decompiler
|
|
(bucket-group dma-bucket :offset-assert 44) ;; (inline-array dma-bucket)
|
|
(profile-array profile-array :inline :offset-assert 48)
|
|
(start-time uint64 :offset-assert 56) ;; int64
|
|
(run-time uint64 :offset-assert 64) ;; int64
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype display (basic)
|
|
((on-screen int32 :offset-assert 4)
|
|
(last-screen int32 :offset-assert 8)
|
|
(frames display-frame 2 :offset-assert 12) ;; guessed by decompiler
|
|
(bgcolor uint64 :offset-assert 24) ;; gs-bgcolor
|
|
(pmode uint64 :offset-assert 32) ;; gs-pmode
|
|
(clock clock 22 :offset-assert 40) ;; guessed by decompiler
|
|
(session-clock clock :offset-assert 40) ;; guessed by decompiler
|
|
(game-clock clock :offset-assert 44) ;; guessed by decompiler
|
|
(base-clock clock :offset-assert 48) ;; guessed by decompiler
|
|
(real-clock clock :offset-assert 52) ;; guessed by decompiler
|
|
(frame-clock clock :offset-assert 56) ;; guessed by decompiler
|
|
(real-frame-clock clock :offset-assert 60) ;; guessed by decompiler
|
|
(target-clock clock :offset-assert 64) ;; guessed by decompiler
|
|
(entity-clock clock :offset-assert 68) ;; guessed by decompiler
|
|
(part-clock clock :offset-assert 72) ;; guessed by decompiler
|
|
(bg-clock clock :offset-assert 76) ;; guessed by decompiler
|
|
(camera-clock clock :offset-assert 80) ;; guessed by decompiler
|
|
(total-game-clock clock :offset-assert 84) ;; guessed by decompiler
|
|
(user0-clock clock :offset-assert 88) ;; guessed by decompiler
|
|
(user1-clock basic :offset-assert 92)
|
|
(user2-clock basic :offset-assert 96)
|
|
(user3-clock basic :offset-assert 100)
|
|
(user4-clock basic :offset-assert 104)
|
|
(user5-clock basic :offset-assert 108)
|
|
(user6-clock basic :offset-assert 112)
|
|
(user7-clock basic :offset-assert 116)
|
|
(user8-clock basic :offset-assert 120)
|
|
(user9-clock basic :offset-assert 124)
|
|
(time-factor float :offset-assert 128)
|
|
(dog-ratio float :offset-assert 132)
|
|
(vblank-start-time int64 2 :offset-assert 136) ;; guessed by decompiler
|
|
(total-run-time uint64 :offset-assert 152) ;; int64
|
|
(run-half-speed basic :offset-assert 160)
|
|
(vu1-enable-user uint64 :offset-assert 168) ;; vu1-renderer-mask
|
|
(vu1-enable-user-menu uint64 :offset-assert 176) ;; vu1-renderer-mask
|
|
(force-sync uint32 :offset-assert 184)
|
|
(mem-reserve-size uint32 :offset-assert 188)
|
|
(dma-buffer-overflow basic :offset-assert 192)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xc4
|
|
:flag-assert #xa000000c4
|
|
(:methods
|
|
;; (new (symbol type int int int int int) _type_ 0)
|
|
(display-method-9 () none) ;; 9 ;; (set-time-ratios (_type_ float) float 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *pre-draw-hook* object) ;; (function object none)
|
|
;; (define-extern *post-draw-hook* object) ;; (function dma-buffer none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; editable ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern common-owner function)
|
|
;; (define-extern update-light-sphere-from-editable-light function) ;; (function editable-light none)
|
|
;; (define-extern load-editable-lights function)
|
|
;; (define-extern *editable-sample-region* object) ;; editable-region
|
|
;; (define-extern *editable-light-region* object) ;; editable-region
|
|
;; (define-extern *editable-entity-region* object) ;; editable-region
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; grunt ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype grunt-anim-info (structure)
|
|
((anim-index int32 :offset-assert 0)
|
|
(travel-speed meters :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype grunt-global-info (basic)
|
|
((patrol-anim grunt-anim-info 4 :offset-assert 4) ;; guessed by decompiler
|
|
(charge-anim grunt-anim-info 3 :offset-assert 36) ;; guessed by decompiler
|
|
(attack-anim grunt-anim-info 2 :offset-assert 60) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype grunt (nav-enemy)
|
|
((patrol-anim grunt-anim-info :offset-assert 620)
|
|
(charge-anim grunt-anim-info :offset-assert 624)
|
|
(attack-anim grunt-anim-info :offset-assert 628)
|
|
(intro-path path-control :offset-assert 632) ;; guessed by decompiler
|
|
(use-charge-anim-index int8 :offset-assert 640)
|
|
(jumping-ambush-path-pt int8 :offset-assert 641)
|
|
(grunt-flags uint8 :offset-assert 642)
|
|
(state-timeout2 uint64 :offset-assert 648)
|
|
(next-warn-time uint64 :offset-assert 656) ;; time-frame
|
|
(dest vector :inline :offset-assert 672)
|
|
(focus-pos vector :inline :offset-assert 352)
|
|
(minimap connection-minimap :offset-assert 704)
|
|
)
|
|
:method-count-assert 198
|
|
:size-assert #x2c4
|
|
:flag-assert #xc6025002c4
|
|
(:methods
|
|
(grunt-method-196 () none) ;; 196
|
|
(grunt-method-197 () none) ;; 197
|
|
)
|
|
(:state-methods
|
|
falling-ambush ;; 191
|
|
jumping-ambush ;; 192
|
|
jumping-ambush-cont ;; 193
|
|
active ;; 34
|
|
attack ;; 190
|
|
hostile ;; 38
|
|
spin-attack ;; 195
|
|
circling ;; 157
|
|
pacing ;; 156
|
|
stop-chase ;; 158
|
|
wait-for-focus ;; 194
|
|
knocked-recover ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *grunt-global-info* grunt-global-info) ;; grunt-global-info
|
|
;; (define-extern *grunt-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctywide-tasks ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-city-vehicle-training-hover-zone-1 (task-manager)
|
|
((speech-id uint32 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf4
|
|
:flag-assert #x20008000f4
|
|
(:state-methods
|
|
active ;; 15
|
|
fail ;; 18
|
|
complete ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-city-vehicle-training-hover-zone-2 (task-manager)
|
|
((speech-id uint32 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf4
|
|
:flag-assert #x20008000f4
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-hijack-intro (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-force-load-borrows (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-blackout (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern wait-for-speech-end function) ;; (function sound-id none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-boss-setup ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype factory-boss-speech-instance (structure)
|
|
((speech basic :offset-assert 0)
|
|
(probability float :offset-assert 4)
|
|
(flags uint64 :offset-assert 8)
|
|
(play-count uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-speech-info (structure)
|
|
((speeches basic :offset-assert 0)
|
|
(play-time uint64 :offset-assert 8)
|
|
(current-random uint64 :offset-assert 16)
|
|
(minimum-interval uint64 :offset-assert 24)
|
|
(random-interval uint64 :offset-assert 32)
|
|
(last-played int8 :offset-assert 40)
|
|
(flags uint8 :offset-assert 41)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2a
|
|
:flag-assert #x90000002a
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-speech-group (structure)
|
|
((play-time uint64 :offset-assert 0)
|
|
(info basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-reticle-info (structure)
|
|
((reticle basic :offset-assert 0)
|
|
(reticle-corner-0 basic :offset-assert 4)
|
|
(reticle-corner-1 basic :offset-assert 8)
|
|
(reticle-corner-2 basic :offset-assert 12)
|
|
(reticle-corner-3 basic :offset-assert 16)
|
|
(reticle-dot basic :offset-assert 20)
|
|
(reticle-arrow basic :offset-assert 24)
|
|
(reticle-super basic :offset-assert 28)
|
|
(reticle-super-ring basic :offset-assert 32)
|
|
(lock-time uint64 :offset-assert 40)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
(:methods
|
|
(factory-boss-reticle-info-method-9 () none) ;; 9
|
|
(factory-boss-reticle-info-method-10 () none) ;; 10
|
|
(factory-boss-reticle-info-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-shot (projectile)
|
|
((trail-part basic :offset-assert 512)
|
|
(traj trajectory :inline :offset-assert 528)
|
|
(traj-time uint64 :offset-assert 568)
|
|
(shot-dest vector :inline :offset-assert 576)
|
|
(impact-played basic :offset-assert 592)
|
|
(reticle-sound uint32 :offset-assert 596)
|
|
(reticle-sound-playing basic :offset-assert 600)
|
|
)
|
|
:method-count-assert 42
|
|
:size-assert #x25c
|
|
:flag-assert #x2a01e0025c
|
|
(:methods
|
|
(factory-boss-shot-method-41 () none) ;; 41
|
|
)
|
|
(:state-methods
|
|
moving ;; 23
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-shockwave-bomb (factory-boss-shot)
|
|
()
|
|
:method-count-assert 42
|
|
:size-assert #x25c
|
|
:flag-assert #x2a01e0025c
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shockwave-bomb-explosion (explosion)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #x168
|
|
:flag-assert #x1700f00168
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-floorbuster-bomb (factory-boss-shot)
|
|
((targetted-group int8 :offset-assert 604)
|
|
)
|
|
:method-count-assert 42
|
|
:size-assert #x25d
|
|
:flag-assert #x2a01e0025d
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype floorbuster-bomb-explosion (explosion)
|
|
((targetted-group int8 :offset-assert 360)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x169
|
|
:flag-assert #x1700f00169
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-drop-plat-nocollide (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-drop-plat (process-drawable)
|
|
((x-rotation-speed float :offset-assert 200)
|
|
(y-rotation-speed float :offset-assert 204)
|
|
(boss basic :offset-assert 208)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd4
|
|
:flag-assert #x17006000d4
|
|
(:state-methods
|
|
idle ;; 20
|
|
fall-away ;; 21
|
|
done-falling ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-critter-tracker (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(flags uint32 :offset-assert 8)
|
|
(dest vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-machine-state (structure)
|
|
((damaged-low-smoke-part basic :offset-assert 0)
|
|
(damaged-high-smoke-part basic :offset-assert 4)
|
|
(damaged-left-spark-part basic :offset-assert 8)
|
|
(damaged-right-spark-part basic :offset-assert 12)
|
|
(ring-part basic :offset-assert 16)
|
|
(lightning basic :offset-assert 20)
|
|
(machine-sound uint32 :offset-assert 24)
|
|
(state int8 :offset-assert 28)
|
|
(flags uint8 :offset-assert 29)
|
|
(left-spark-timer uint64 :offset-assert 32)
|
|
(right-spark-timer uint64 :offset-assert 40)
|
|
(ring-timer uint64 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss-lightning-gate (structure)
|
|
((center vector :inline :offset-assert 0)
|
|
(x-off float :offset-assert 16)
|
|
(z-off float :offset-assert 20)
|
|
(blocking-plane uint64 :offset-assert 24)
|
|
(lightning UNKNOWN 4 :offset-assert 32)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
(:methods
|
|
(factory-boss-lightning-gate-method-9 () none) ;; 9
|
|
(factory-boss-lightning-gate-method-10 () none) ;; 10
|
|
(factory-boss-lightning-gate-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-boss (process-drawable)
|
|
((center vector :inline :offset-assert 204)
|
|
(shot-timer uint64 :offset-assert 220)
|
|
(critter UNKNOWN 8 :offset-assert 236)
|
|
(ammo UNKNOWN 10 :offset-assert 492)
|
|
(catwalk-angle float :offset-assert 572)
|
|
(catwalk-vel float :offset-assert 576)
|
|
(bombs-to-drop int8 :offset-assert 580)
|
|
(bomb-type uint64 :offset-assert 588)
|
|
(root-angle float :offset-assert 596)
|
|
(machine-state UNKNOWN 4 :offset-assert 604)
|
|
(chosen-machine int8 :offset-assert 860)
|
|
(command-index int8 :offset-assert 861)
|
|
(command-timer uint64 :offset-assert 868)
|
|
(current-round int32 :offset-assert 876)
|
|
(hits-taken int8 :offset-assert 880)
|
|
(camera-timer uint64 :offset-assert 884)
|
|
(reticle-info factory-boss-reticle-info :inline :offset-assert 892)
|
|
(actor-group uint32 :offset-assert 940)
|
|
(actor-group-count int32 :offset-assert 944)
|
|
(launching-group basic :offset-assert 948)
|
|
(floor-targets UNKNOWN 7 :offset-assert 952)
|
|
(num-floor-targets int8 :offset-assert 959)
|
|
(reticle-sound uint32 :offset-assert 960)
|
|
(reticle-sound-playing basic :offset-assert 964)
|
|
(warp-blocker factory-boss-lightning-gate :inline :offset-assert 972)
|
|
(entry-blocker factory-boss-lightning-gate :inline :offset-assert 1020)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #x430
|
|
:flag-assert #x1f03b00430
|
|
(:methods
|
|
(factory-boss-method-20 () none) ;; 20
|
|
(factory-boss-method-21 () none) ;; 21
|
|
(factory-boss-method-22 () none) ;; 22
|
|
(factory-boss-method-23 () none) ;; 23
|
|
(factory-boss-method-24 () none) ;; 24
|
|
(factory-boss-method-25 () none) ;; 25
|
|
(factory-boss-method-26 () none) ;; 26
|
|
(factory-boss-method-27 () none) ;; 27
|
|
(factory-boss-method-28 () none) ;; 28
|
|
(factory-boss-method-29 () none) ;; 29
|
|
(factory-boss-method-30 () none) ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-factory-boss (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-factory-boss (task-manager)
|
|
((button-up basic :offset-assert 240)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xf4
|
|
:flag-assert #x21008000f4
|
|
(:methods
|
|
(task-manager-factory-boss-method-32 () none) ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-warp-effect (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *factory-boss-dead-pool* object)
|
|
;; (define-extern *factory-boss-speech* object)
|
|
;; (define-extern reset-factory-boss-speeches function)
|
|
;; (define-extern factory-boss-play-speech function)
|
|
;; (define-extern fac-drop-plat-nocollide-init-by-other function)
|
|
;; (define-extern fac-drop-plat-setup-rots function)
|
|
;; (define-extern fac-drop-plat-rot-once function)
|
|
;; (define-extern fac-drop-plat-init-by-other function)
|
|
;; (define-extern factoryd-login function)
|
|
;; (define-extern factoryd-logout function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; geometry ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern vector-flatten! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-reflect! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-reflect-flat! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-reflect-flat-above! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-reflect-flat-gravity! function) ;; (function vector vector vector vector vector)
|
|
;; (define-extern vector-segment-distance-point! function) ;; (function vector vector vector vector float)
|
|
;; (define-extern vector-segment-xz-distance-point! function)
|
|
;; (define-extern vector-line-distance function) ;; (function vector vector vector float)
|
|
;; (define-extern vector-line-distance-point! function) ;; (function vector vector vector vector float)
|
|
;; (define-extern vector-line-xz-distance-point! function)
|
|
;; (define-extern vector-segment-overlap function) ;; (function vector vector vector float)
|
|
;; (define-extern line-sphere-intersection? function) ;; (function vector vector vector symbol)
|
|
;; (define-extern nearest-dist2-between-moving-points function) ;; (function vector vector vector vector float float)
|
|
;; (define-extern vector-orient-by-quat! function) ;; (function vector vector quaternion vector)
|
|
;; (define-extern vector-inv-orient-by-quat! function) ;; (function vector vector quaternion vector)
|
|
;; (define-extern forward-down->inv-matrix function) ;; (function matrix vector vector matrix)
|
|
;; (define-extern forward-down-nopitch->inv-matrix function) ;; (function matrix vector vector matrix)
|
|
;; (define-extern forward-up->inv-matrix function) ;; (function matrix vector vector matrix)
|
|
;; (define-extern forward-up-nopitch->inv-matrix function) ;; (function matrix vector vector matrix)
|
|
;; (define-extern forward-up-nopitch->quaternion function) ;; (function quaternion vector vector quaternion)
|
|
;; (define-extern forward-up->quaternion function) ;; (function quaternion vector vector quaternion)
|
|
;; (define-extern quaternion-from-two-vectors! function) ;; (function quaternion vector vector quaternion)
|
|
;; (define-extern quaternion-from-two-vectors-partial! function) ;; (function quaternion vector vector float quaternion)
|
|
;; (define-extern quaternion-from-two-vectors-max-angle! function) ;; (function quaternion vector vector float quaternion)
|
|
;; (define-extern quaternion-from-two-vectors-max-angle-partial! function) ;; (function quaternion vector vector float float quaternion)
|
|
;; (define-extern matrix-from-two-vectors! function) ;; (function matrix vector vector matrix)
|
|
;; (define-extern matrix-from-two-vectors-max-angle! function) ;; (function matrix vector vector float matrix)
|
|
;; (define-extern matrix-from-two-vectors-smooth! function) ;; (function matrix vector vector float int matrix)
|
|
;; (define-extern matrix-from-two-vectors-the-long-way-smooth! function) ;; (function matrix vector vector float int matrix)
|
|
;; (define-extern quaternion-from-two-vectors-smooth! function) ;; (function quaternion vector vector float int quaternion)
|
|
;; (define-extern matrix-from-two-vectors-max-angle-partial! function) ;; (function matrix vector vector float float matrix)
|
|
;; (define-extern matrix-from-two-vectors-partial-linear! function) ;; (function matrix vector vector float matrix)
|
|
;; (define-extern matrix-remove-z-rot function) ;; (function matrix vector matrix)
|
|
;; (define-extern matrix-rot-diff! function) ;; (function vector matrix matrix float)
|
|
;; (define-extern quaternion-seek function) ;; (function quaternion quaternion quaternion float float quaternion)
|
|
;; (define-extern vector-deg-seek function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector-deg-slerp function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector-vector-deg-slerp! function) ;; (function vector vector vector float vector vector)
|
|
;; (define-extern normal-of-plane function) ;; (function vector vector vector vector vector)
|
|
;; (define-extern vector-3pt-cross! function) ;; (function vector vector vector vector vector)
|
|
;; (define-extern closest-pt-in-triangle function) ;; (function vector vector matrix vector none)
|
|
;; (define-extern point-in-triangle-cross function) ;; (function vector vector vector vector vector symbol)
|
|
;; (define-extern point-in-plane-<-point+normal! function) ;; (function vector vector vector vector)
|
|
;; (define-extern circle-circle-xz-intersect function) ;; (function sphere sphere vector vector int)
|
|
;; (define-extern circle-test function) ;; (function none)
|
|
;; (define-extern vector-circle-tangent-new function) ;; (function vector vector vector vector none)
|
|
;; (define-extern vector-circle-tangent function) ;; (function vector vector vector vector none)
|
|
;; (define-extern find-knot-span function) ;; (function int int float (inline-array vector) int)
|
|
;; (define-extern calculate-basis-functions-vector! function) ;; (function vector int float (pointer float) vector)
|
|
;; (define-extern curve-evaluate! function) ;; (function vector float (inline-array vector) int (pointer float) int vector)
|
|
;; (define-extern curve-get-pos! function) ;; (function vector float curve vector)
|
|
;; (define-extern curve-length function) ;; (function curve float)
|
|
;; (define-extern curve-copy! function) ;; (function curve curve curve)
|
|
;; (define-extern curve-closest-point function) ;; (function curve vector float float int float float)
|
|
;; (define-extern vector-plane-distance function) ;; (function vector plane vector float)
|
|
;; (define-extern intersect-ray-plane function) ;; (function vector vector vector vector float)
|
|
;; (define-extern line-line-find-intersection-xz function)
|
|
;; (define-extern segment-segment-find-intersection-xz function)
|
|
;; (define-extern generate-rand-vector-on-sphere function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-sewg ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sewg-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rubble-attack ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rub-missile (metalhead-grenade-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x214
|
|
:flag-assert #x2901a00214
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dm-missile-target (process-drawable)
|
|
((ring-jmod UNKNOWN 2 :offset-assert 200)
|
|
(ring-timer uint64 :offset-assert 208)
|
|
(blink-timer uint64 :offset-assert 216)
|
|
(target-sound-id uint32 :offset-assert 224)
|
|
(warn-sound-id uint32 :offset-assert 228)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xe8
|
|
:flag-assert #x16007000e8
|
|
(:state-methods
|
|
idle ;; 20
|
|
lock ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rubble-attack-manager (task-manager)
|
|
((missile-spawners basic :offset-assert 240)
|
|
(missile uint64 :offset-assert 248)
|
|
(missile-target uint64 :offset-assert 256)
|
|
(missile-timer uint64 :offset-assert 264)
|
|
(vehicle-handle uint64 :offset-assert 272)
|
|
(king-rider uint64 :offset-assert 280)
|
|
(talk-timer uint64 :offset-assert 288)
|
|
(played-speeches uint32 :offset-assert 296)
|
|
(first-dp-noticed? basic :offset-assert 300)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x130
|
|
:flag-assert #x2300b00130
|
|
(:methods
|
|
(rubble-attack-manager-method-32 () none) ;; 32
|
|
(rubble-attack-manager-method-33 () none) ;; 33
|
|
(rubble-attack-manager-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern dm-missile-target-post function)
|
|
;; (define-extern dm-missile-target-handler function)
|
|
;; (define-extern *dm-missile-target-shadow-control* shadow-control)
|
|
;; (define-extern dm-missile-target-init-by-other function)
|
|
;; (define-extern *missile-spawners-all* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vector ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern vector-cross! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-xz-cross! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector+float! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector*! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector+*! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector-*! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector/! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-float*! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-average! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector+float*! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector--float*! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector-min! function)
|
|
;; (define-extern vector-max! function)
|
|
;; (define-extern vector-float/! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-negate! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-negate-in-place! function) ;; (function vector vector)
|
|
;; (define-extern vector= function) ;; (function vector vector symbol)
|
|
;; (define-extern vector-delta function) ;; (function vector vector float)
|
|
;; (define-extern vector-seek! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-smooth-seek! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-seek-2d-xz-smooth! function) ;; (function vector vector float float vector)
|
|
;; (define-extern vector-seek-2d-yz-smooth! function) ;; (function vector vector float float vector)
|
|
;; (define-extern vector-seek-3d-smooth! function) ;; (function vector vector float float vector)
|
|
;; (define-extern seek-with-smooth function) ;; (function float float float float float float)
|
|
;; (define-extern vector-identity! function) ;; (function vector vector)
|
|
;; (define-extern vector-seconds function) ;; (function vector vector vector)
|
|
;; (define-extern vector-seconds! function) ;; (function vector vector)
|
|
;; (define-extern vector-v! function) ;; (function vector vector)
|
|
;; (define-extern vector-v+! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector-v*float+! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector-v++! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-v*float! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-v*float++! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-to-ups! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-from-ups! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-length function) ;; (function vector float)
|
|
;; (define-extern vector-length-squared function) ;; (function vector float)
|
|
;; (define-extern vector-xz-length-squared function) ;; (function vector float)
|
|
;; (define-extern vector-xz-length function) ;; (function vector float)
|
|
;; (define-extern vector-vector-distance function) ;; (function vector vector float)
|
|
;; (define-extern vector-vector-distance-squared function) ;; (function vector vector float)
|
|
;; (define-extern vector-vector-xz-distance function) ;; (function vector vector float)
|
|
;; (define-extern vector-vector-xy-distance function) ;; (function vector vector float)
|
|
;; (define-extern vector-vector-xz-distance-squared function) ;; (function vector vector float)
|
|
;; (define-extern vector-vector-planar-distance function)
|
|
;; (define-extern vector-normalize! function) ;; (function vector float vector)
|
|
;; (define-extern vector-normalize-ret-len! function) ;; (function vector float float)
|
|
;; (define-extern vector-normalize-copy! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-xz-normalize! function) ;; (function vector float vector)
|
|
;; (define-extern vector-xz-normalize-copy! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-length-max! function) ;; (function vector float vector)
|
|
;; (define-extern vector-xz-length-max! function) ;; (function vector float vector)
|
|
;; (define-extern vector-rotate-around-x! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-rotate-around-y! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector-rotate90-around-y! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-rotate-around-z! function) ;; (function vector vector float vector)
|
|
;; (define-extern rotate-y<-vector+vector function) ;; (function vector vector float)
|
|
;; (define-extern rotate-x<-vector+vector function) ;; (function vector vector float)
|
|
;; (define-extern rotate-z<-vector+vector function) ;; (function vector vector float)
|
|
;; (define-extern rotate-vector-to-vector function)
|
|
;; (define-extern vector-cvt.w.s! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-cvt.s.w! function) ;; (function vector vector vector)
|
|
;; (define-extern rot-zxy-from-vector! function) ;; (function vector vector vector)
|
|
;; (define-extern rot-zyx-from-vector! function) ;; (function vector vector vector)
|
|
;; (define-extern vector-lerp! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector-lerp-clamp! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector4-lerp! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector4-lerp-clamp! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector-degi function) ;; (function vector vector vector)
|
|
;; (define-extern vector-degf function) ;; (function vector vector vector)
|
|
;; (define-extern vector-degmod function) ;; (function vector vector vector)
|
|
;; (define-extern vector-deg-diff function) ;; (function vector vector vector none)
|
|
;; (define-extern vector-deg-lerp-clamp! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern vector3s-copy! function) ;; (function vector vector vector)
|
|
;; (define-extern vector3s+! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector3s*float! function) ;; (function vector vector float vector)
|
|
;; (define-extern vector3s-! function) ;; (function vector vector vector vector)
|
|
;; (define-extern vector4-add! function) ;; (function vector4 vector4 vector4 none)
|
|
;; (define-extern vector4-sub! function) ;; (function vector4 vector4 vector4 none)
|
|
;; (define-extern vector4-mul! function) ;; (function vector4 vector4 vector4 none)
|
|
;; (define-extern vector4-scale! function) ;; (function vector4 vector4 float none)
|
|
;; (define-extern vector4-madd! function) ;; (function vector4 vector4 vector4 float none)
|
|
;; (define-extern vector4-msub! function) ;; (function vector4 vector4 vector4 float none)
|
|
;; (define-extern vector4-array-add! function) ;; (function (inline-array vector4) (inline-array vector4) (inline-array vector4) int none)
|
|
;; (define-extern vector4-array-sub! function) ;; (function (inline-array vector4) (inline-array vector4) (inline-array vector4) int none)
|
|
;; (define-extern vector4-array-mul! function) ;; (function (inline-array vector4) (inline-array vector4) (inline-array vector4) int none)
|
|
;; (define-extern vector4-array-scale! function) ;; (function (inline-array vector4) (inline-array vector4) float int none)
|
|
;; (define-extern vector4-array-madd! function) ;; (function (inline-array vector4) (inline-array vector4) (inline-array vector4) float int none)
|
|
;; (define-extern vector4-array-msub! function) ;; (function (inline-array vector4) (inline-array vector4) (inline-array vector4) float int none)
|
|
;; (define-extern vector4-array-lerp! function) ;; (function (inline-array vector4) (inline-array vector4) (inline-array vector4) float int symbol)
|
|
;; (define-extern spheres-overlap? function) ;; (function sphere sphere symbol)
|
|
;; (define-extern sphere<-vector! function) ;; (function sphere vector sphere)
|
|
;; (define-extern sphere<-vector+r! function) ;; (function sphere vector float sphere)
|
|
;; (define-extern rand-vu-sphere-point! function) ;; (function vector float vector)
|
|
;; (define-extern rand-vu-sphere-point-uniform! function)
|
|
;; (define-extern vector-vector-angle-safe function) ;; (function vector vector float)
|
|
;; (define-extern vector-get-unique! function)
|
|
;; (define-extern vector-get-closest-perpendicular! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; timer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern timer-count function) ;; (function timer-bank uint)
|
|
;; (define-extern disable-irq function) ;; (function none)
|
|
;; (define-extern enable-irq function) ;; (function none)
|
|
;; (define-extern stopwatch-init function) ;; (function stopwatch int)
|
|
;; (define-extern stopwatch-reset function) ;; (function stopwatch int)
|
|
;; (define-extern stopwatch-start function) ;; (function stopwatch int)
|
|
;; (define-extern stopwatch-stop function) ;; (function stopwatch none)
|
|
;; (define-extern stopwatch-begin function) ;; (function stopwatch int)
|
|
;; (define-extern stopwatch-end function) ;; (function stopwatch none)
|
|
;; (define-extern stopwatch-elapsed-ticks function) ;; (function stopwatch time-frame)
|
|
;; (define-extern stopwatch-elapsed-seconds function) ;; (function stopwatch float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; file-io ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype file-stream (basic)
|
|
((flags uint32 :offset-assert 4)
|
|
(mode symbol :offset-assert 8) ;; guessed by decompiler
|
|
(name string :offset-assert 12) ;; guessed by decompiler
|
|
(file uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype file-info (basic)
|
|
((file-type (pointer string) :offset-assert 4) ;; guessed by decompiler
|
|
(file-name basic :offset-assert 8)
|
|
(major-version uint32 :offset-assert 12)
|
|
(minor-version uint32 :offset-assert 16)
|
|
(maya-file-name basic :offset-assert 20)
|
|
(tool-debug basic :offset-assert 24)
|
|
(mdb-file-name basic :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
;; (define-extern file-stream-read-string function) ;; (function file-stream string string)
|
|
;; (define-extern *file-temp-string* object) ;; string
|
|
;; (define-extern make-file-name function) ;; (function file-kind string int symbol string)
|
|
;; (define-extern make-vfile-name function) ;; (function file-kind string string)
|
|
;; (define-extern file-info-correct-version? function) ;; (function file-info file-kind int symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; game-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype process-drawable (process)
|
|
((root trsqv :offset-assert 128) ;; guessed by decompiler
|
|
(node-list cspace-array :offset-assert 132) ;; guessed by decompiler
|
|
(draw draw-control :offset-assert 136) ;; guessed by decompiler
|
|
(skel joint-control :offset-assert 140) ;; guessed by decompiler
|
|
(nav nav-control :offset-assert 144) ;; guessed by decompiler
|
|
(align align-control :offset-assert 148) ;; guessed by decompiler
|
|
(path path-control :offset-assert 152) ;; guessed by decompiler
|
|
(vol vol-control :offset-assert 156) ;; guessed by decompiler
|
|
(fact fact-info :offset-assert 160) ;; guessed by decompiler
|
|
(link actor-link-info :offset-assert 164) ;; guessed by decompiler
|
|
(part sparticle-launch-control :offset-assert 168) ;; guessed by decompiler
|
|
(water water-control :offset-assert 172) ;; guessed by decompiler
|
|
(sound ambient-sound :offset-assert 176) ;; guessed by decompiler
|
|
(carry carry-info :offset-assert 180) ;; guessed by decompiler
|
|
(rbody rigid-body-control :offset-assert 184) ;; guessed by decompiler
|
|
(state-flags state-flags :offset-assert 188) ;; guessed by decompiler
|
|
(state-time uint64 :offset-assert 192) ;; time-frame
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #xc8
|
|
:flag-assert #x14005000c8
|
|
(:methods
|
|
(process-drawable-method-14 () none) ;; 14 ;; (initialize-skeleton (_type_ skeleton-group pair) draw-control 14)
|
|
(process-drawable-method-15 () none) ;; 15 ;; (initialize-skeleton-by-name (_type_ string) draw-control 15)
|
|
(process-drawable-method-16 () none) ;; 16 ;; (apply-alignment (_type_ align-opts transformq vector) trsqv 16)
|
|
(process-drawable-method-17 () none) ;; 17 ;; (cleanup-for-death (_type_) none 17)
|
|
(process-drawable-method-18 () none) ;; 18 ;; (relocate-nav (_type_ int) none 18)
|
|
(process-drawable-method-19 () none) ;; 19 ;; (evaluate-joint-control (_type_) none 19)
|
|
)
|
|
(:states
|
|
process-drawable-art-error ;; associated process guessed by decompiler, old: (state string process-drawable)
|
|
process-drawable-idle ;; associated process guessed by decompiler, old: (state process-drawable)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype process-drawable-reserved (process-drawable)
|
|
()
|
|
:method-count-assert 218
|
|
:size-assert #xc8
|
|
:flag-assert #xda005000c8
|
|
(:methods
|
|
(process-drawable-reserved-method-20 () none) ;; 20 ;; (process-drawable-reserved-method-20 () none 20)
|
|
(process-drawable-reserved-method-21 () none) ;; 21 ;; (process-drawable-reserved-method-21 () none 21)
|
|
(process-drawable-reserved-method-22 () none) ;; 22 ;; (process-drawable-reserved-method-22 () none 22)
|
|
(process-drawable-reserved-method-23 () none) ;; 23 ;; (process-drawable-reserved-method-23 () none 23)
|
|
(process-drawable-reserved-method-24 () none) ;; 24 ;; (process-drawable-reserved-method-24 () none 24)
|
|
(process-drawable-reserved-method-25 () none) ;; 25 ;; (process-drawable-reserved-method-25 () none 25)
|
|
(process-drawable-reserved-method-26 () none) ;; 26 ;; (process-drawable-reserved-method-26 () none 26)
|
|
(process-drawable-reserved-method-27 () none) ;; 27 ;; (process-drawable-reserved-method-27 () none 27)
|
|
(process-drawable-reserved-method-28 () none) ;; 28 ;; (process-drawable-reserved-method-28 () none 28)
|
|
(process-drawable-reserved-method-29 () none) ;; 29 ;; (process-drawable-reserved-method-29 () none 29)
|
|
(process-drawable-reserved-method-30 () none) ;; 30 ;; (process-drawable-reserved-method-30 () none 30)
|
|
(process-drawable-reserved-method-31 () none) ;; 31 ;; (process-drawable-reserved-method-31 () none 31)
|
|
(process-drawable-reserved-method-32 () none) ;; 32 ;; (process-drawable-reserved-method-32 () none 32)
|
|
(process-drawable-reserved-method-33 () none) ;; 33 ;; (process-drawable-reserved-method-33 () none 33)
|
|
(process-drawable-reserved-method-34 () none) ;; 34 ;; (process-drawable-reserved-method-34 () none 34)
|
|
(process-drawable-reserved-method-35 () none) ;; 35 ;; (process-drawable-reserved-method-35 () none 35)
|
|
(process-drawable-reserved-method-36 () none) ;; 36 ;; (process-drawable-reserved-method-36 () none 36)
|
|
(process-drawable-reserved-method-37 () none) ;; 37 ;; (process-drawable-reserved-method-37 () none 37)
|
|
(process-drawable-reserved-method-38 () none) ;; 38 ;; (process-drawable-reserved-method-38 () none 38)
|
|
(process-drawable-reserved-method-39 () none) ;; 39 ;; (process-drawable-reserved-method-39 () none 39)
|
|
(process-drawable-reserved-method-40 () none) ;; 40 ;; (process-drawable-reserved-method-40 () none 40)
|
|
(process-drawable-reserved-method-41 () none) ;; 41 ;; (process-drawable-reserved-method-41 () none 41)
|
|
(process-drawable-reserved-method-42 () none) ;; 42 ;; (process-drawable-reserved-method-42 () none 42)
|
|
(process-drawable-reserved-method-43 () none) ;; 43 ;; (process-drawable-reserved-method-43 () none 43)
|
|
(process-drawable-reserved-method-44 () none) ;; 44 ;; (process-drawable-reserved-method-44 () none 44)
|
|
(process-drawable-reserved-method-45 () none) ;; 45 ;; (process-drawable-reserved-method-45 () none 45)
|
|
(process-drawable-reserved-method-46 () none) ;; 46 ;; (process-drawable-reserved-method-46 () none 46)
|
|
(process-drawable-reserved-method-47 () none) ;; 47 ;; (process-drawable-reserved-method-47 () none 47)
|
|
(process-drawable-reserved-method-48 () none) ;; 48 ;; (process-drawable-reserved-method-48 () none 48)
|
|
(process-drawable-reserved-method-49 () none) ;; 49 ;; (process-drawable-reserved-method-49 () none 49)
|
|
(process-drawable-reserved-method-50 () none) ;; 50 ;; (process-drawable-reserved-method-50 () none 50)
|
|
(process-drawable-reserved-method-51 () none) ;; 51 ;; (process-drawable-reserved-method-51 () none 51)
|
|
(process-drawable-reserved-method-52 () none) ;; 52 ;; (process-drawable-reserved-method-52 () none 52)
|
|
(process-drawable-reserved-method-53 () none) ;; 53 ;; (process-drawable-reserved-method-53 () none 53)
|
|
(process-drawable-reserved-method-54 () none) ;; 54 ;; (process-drawable-reserved-method-54 () none 54)
|
|
(process-drawable-reserved-method-55 () none) ;; 55 ;; (process-drawable-reserved-method-55 () none 55)
|
|
(process-drawable-reserved-method-56 () none) ;; 56 ;; (process-drawable-reserved-method-56 () none 56)
|
|
(process-drawable-reserved-method-57 () none) ;; 57 ;; (process-drawable-reserved-method-57 () none 57)
|
|
(process-drawable-reserved-method-58 () none) ;; 58 ;; (process-drawable-reserved-method-58 () none 58)
|
|
(process-drawable-reserved-method-59 () none) ;; 59 ;; (process-drawable-reserved-method-59 () none 59)
|
|
(process-drawable-reserved-method-60 () none) ;; 60 ;; (process-drawable-reserved-method-60 () none 60)
|
|
(process-drawable-reserved-method-61 () none) ;; 61 ;; (process-drawable-reserved-method-61 () none 61)
|
|
(process-drawable-reserved-method-62 () none) ;; 62 ;; (process-drawable-reserved-method-62 () none 62)
|
|
(process-drawable-reserved-method-63 () none) ;; 63 ;; (process-drawable-reserved-method-63 () none 63)
|
|
(process-drawable-reserved-method-64 () none) ;; 64 ;; (process-drawable-reserved-method-64 () none 64)
|
|
(process-drawable-reserved-method-65 () none) ;; 65 ;; (process-drawable-reserved-method-65 () none 65)
|
|
(process-drawable-reserved-method-66 () none) ;; 66 ;; (process-drawable-reserved-method-66 () none 66)
|
|
(process-drawable-reserved-method-67 () none) ;; 67 ;; (process-drawable-reserved-method-67 () none 67)
|
|
(process-drawable-reserved-method-68 () none) ;; 68 ;; (process-drawable-reserved-method-68 () none 68)
|
|
(process-drawable-reserved-method-69 () none) ;; 69 ;; (process-drawable-reserved-method-69 () none 69)
|
|
(process-drawable-reserved-method-70 () none) ;; 70 ;; (process-drawable-reserved-method-70 () none 70)
|
|
(process-drawable-reserved-method-71 () none) ;; 71 ;; (process-drawable-reserved-method-71 () none 71)
|
|
(process-drawable-reserved-method-72 () none) ;; 72 ;; (process-drawable-reserved-method-72 () none 72)
|
|
(process-drawable-reserved-method-73 () none) ;; 73 ;; (process-drawable-reserved-method-73 () none 73)
|
|
(process-drawable-reserved-method-74 () none) ;; 74 ;; (process-drawable-reserved-method-74 () none 74)
|
|
(process-drawable-reserved-method-75 () none) ;; 75 ;; (process-drawable-reserved-method-75 () none 75)
|
|
(process-drawable-reserved-method-76 () none) ;; 76 ;; (process-drawable-reserved-method-76 () none 76)
|
|
(process-drawable-reserved-method-77 () none) ;; 77 ;; (process-drawable-reserved-method-77 () none 77)
|
|
(process-drawable-reserved-method-78 () none) ;; 78 ;; (process-drawable-reserved-method-78 () none 78)
|
|
(process-drawable-reserved-method-79 () none) ;; 79 ;; (process-drawable-reserved-method-79 () none 79)
|
|
(process-drawable-reserved-method-80 () none) ;; 80 ;; (process-drawable-reserved-method-80 () none 80)
|
|
(process-drawable-reserved-method-81 () none) ;; 81 ;; (process-drawable-reserved-method-81 () none 81)
|
|
(process-drawable-reserved-method-82 () none) ;; 82 ;; (process-drawable-reserved-method-82 () none 82)
|
|
(process-drawable-reserved-method-83 () none) ;; 83 ;; (process-drawable-reserved-method-83 () none 83)
|
|
(process-drawable-reserved-method-84 () none) ;; 84 ;; (process-drawable-reserved-method-84 () none 84)
|
|
(process-drawable-reserved-method-85 () none) ;; 85 ;; (process-drawable-reserved-method-85 () none 85)
|
|
(process-drawable-reserved-method-86 () none) ;; 86 ;; (process-drawable-reserved-method-86 () none 86)
|
|
(process-drawable-reserved-method-87 () none) ;; 87 ;; (process-drawable-reserved-method-87 () none 87)
|
|
(process-drawable-reserved-method-88 () none) ;; 88 ;; (process-drawable-reserved-method-88 () none 88)
|
|
(process-drawable-reserved-method-89 () none) ;; 89 ;; (process-drawable-reserved-method-89 () none 89)
|
|
(process-drawable-reserved-method-90 () none) ;; 90 ;; (process-drawable-reserved-method-90 () none 90)
|
|
(process-drawable-reserved-method-91 () none) ;; 91 ;; (process-drawable-reserved-method-91 () none 91)
|
|
(process-drawable-reserved-method-92 () none) ;; 92 ;; (process-drawable-reserved-method-92 () none 92)
|
|
(process-drawable-reserved-method-93 () none) ;; 93 ;; (process-drawable-reserved-method-93 () none 93)
|
|
(process-drawable-reserved-method-94 () none) ;; 94 ;; (process-drawable-reserved-method-94 () none 94)
|
|
(process-drawable-reserved-method-95 () none) ;; 95 ;; (process-drawable-reserved-method-95 () none 95)
|
|
(process-drawable-reserved-method-96 () none) ;; 96 ;; (process-drawable-reserved-method-96 () none 96)
|
|
(process-drawable-reserved-method-97 () none) ;; 97 ;; (process-drawable-reserved-method-97 () none 97)
|
|
(process-drawable-reserved-method-98 () none) ;; 98 ;; (process-drawable-reserved-method-98 () none 98)
|
|
(process-drawable-reserved-method-99 () none) ;; 99 ;; (process-drawable-reserved-method-99 () none 99)
|
|
(process-drawable-reserved-method-100 () none) ;; 100 ;; (process-drawable-reserved-method-100 () none 100)
|
|
(process-drawable-reserved-method-101 () none) ;; 101 ;; (process-drawable-reserved-method-101 () none 101)
|
|
(process-drawable-reserved-method-102 () none) ;; 102 ;; (process-drawable-reserved-method-102 () none 102)
|
|
(process-drawable-reserved-method-103 () none) ;; 103 ;; (process-drawable-reserved-method-103 () none 103)
|
|
(process-drawable-reserved-method-104 () none) ;; 104 ;; (process-drawable-reserved-method-104 () none 104)
|
|
(process-drawable-reserved-method-105 () none) ;; 105 ;; (process-drawable-reserved-method-105 () none 105)
|
|
(process-drawable-reserved-method-106 () none) ;; 106 ;; (process-drawable-reserved-method-106 () none 106)
|
|
(process-drawable-reserved-method-107 () none) ;; 107 ;; (process-drawable-reserved-method-107 () none 107)
|
|
(process-drawable-reserved-method-108 () none) ;; 108 ;; (process-drawable-reserved-method-108 () none 108)
|
|
(process-drawable-reserved-method-109 () none) ;; 109 ;; (process-drawable-reserved-method-109 () none 109)
|
|
(process-drawable-reserved-method-110 () none) ;; 110 ;; (process-drawable-reserved-method-110 () none 110)
|
|
(process-drawable-reserved-method-111 () none) ;; 111 ;; (process-drawable-reserved-method-111 () none 111)
|
|
(process-drawable-reserved-method-112 () none) ;; 112 ;; (process-drawable-reserved-method-112 () none 112)
|
|
(process-drawable-reserved-method-113 () none) ;; 113 ;; (process-drawable-reserved-method-113 () none 113)
|
|
(process-drawable-reserved-method-114 () none) ;; 114 ;; (process-drawable-reserved-method-114 () none 114)
|
|
(process-drawable-reserved-method-115 () none) ;; 115 ;; (process-drawable-reserved-method-115 () none 115)
|
|
(process-drawable-reserved-method-116 () none) ;; 116 ;; (process-drawable-reserved-method-116 () none 116)
|
|
(process-drawable-reserved-method-117 () none) ;; 117 ;; (process-drawable-reserved-method-117 () none 117)
|
|
(process-drawable-reserved-method-118 () none) ;; 118 ;; (process-drawable-reserved-method-118 () none 118)
|
|
(process-drawable-reserved-method-119 () none) ;; 119 ;; (process-drawable-reserved-method-119 () none 119)
|
|
(process-drawable-reserved-method-120 () none) ;; 120 ;; (process-drawable-reserved-method-120 () none 120)
|
|
(process-drawable-reserved-method-121 () none) ;; 121 ;; (process-drawable-reserved-method-121 () none 121)
|
|
(process-drawable-reserved-method-122 () none) ;; 122 ;; (process-drawable-reserved-method-122 () none 122)
|
|
(process-drawable-reserved-method-123 () none) ;; 123 ;; (process-drawable-reserved-method-123 () none 123)
|
|
(process-drawable-reserved-method-124 () none) ;; 124 ;; (process-drawable-reserved-method-124 () none 124)
|
|
(process-drawable-reserved-method-125 () none) ;; 125 ;; (process-drawable-reserved-method-125 () none 125)
|
|
(process-drawable-reserved-method-126 () none) ;; 126 ;; (process-drawable-reserved-method-126 () none 126)
|
|
(process-drawable-reserved-method-127 () none) ;; 127 ;; (process-drawable-reserved-method-127 () none 127)
|
|
(process-drawable-reserved-method-128 () none) ;; 128 ;; (process-drawable-reserved-method-128 () none 128)
|
|
(process-drawable-reserved-method-129 () none) ;; 129 ;; (process-drawable-reserved-method-129 () none 129)
|
|
(process-drawable-reserved-method-130 () none) ;; 130 ;; (process-drawable-reserved-method-130 () none 130)
|
|
(process-drawable-reserved-method-131 () none) ;; 131 ;; (process-drawable-reserved-method-131 () none 131)
|
|
(process-drawable-reserved-method-132 () none) ;; 132 ;; (process-drawable-reserved-method-132 () none 132)
|
|
(process-drawable-reserved-method-133 () none) ;; 133 ;; (process-drawable-reserved-method-133 () none 133)
|
|
(process-drawable-reserved-method-134 () none) ;; 134 ;; (process-drawable-reserved-method-134 () none 134)
|
|
(process-drawable-reserved-method-135 () none) ;; 135 ;; (process-drawable-reserved-method-135 () none 135)
|
|
(process-drawable-reserved-method-136 () none) ;; 136 ;; (process-drawable-reserved-method-136 () none 136)
|
|
(process-drawable-reserved-method-137 () none) ;; 137 ;; (process-drawable-reserved-method-137 () none 137)
|
|
(process-drawable-reserved-method-138 () none) ;; 138 ;; (process-drawable-reserved-method-138 () none 138)
|
|
(process-drawable-reserved-method-139 () none) ;; 139 ;; (process-drawable-reserved-method-139 () none 139)
|
|
(process-drawable-reserved-method-140 () none) ;; 140 ;; (process-drawable-reserved-method-140 () none 140)
|
|
(process-drawable-reserved-method-141 () none) ;; 141 ;; (process-drawable-reserved-method-141 () none 141)
|
|
(process-drawable-reserved-method-142 () none) ;; 142 ;; (process-drawable-reserved-method-142 () none 142)
|
|
(process-drawable-reserved-method-143 () none) ;; 143 ;; (process-drawable-reserved-method-143 () none 143)
|
|
(process-drawable-reserved-method-144 () none) ;; 144 ;; (process-drawable-reserved-method-144 () none 144)
|
|
(process-drawable-reserved-method-145 () none) ;; 145 ;; (process-drawable-reserved-method-145 () none 145)
|
|
(process-drawable-reserved-method-146 () none) ;; 146 ;; (process-drawable-reserved-method-146 () none 146)
|
|
(process-drawable-reserved-method-147 () none) ;; 147 ;; (process-drawable-reserved-method-147 () none 147)
|
|
(process-drawable-reserved-method-148 () none) ;; 148 ;; (process-drawable-reserved-method-148 () none 148)
|
|
(process-drawable-reserved-method-149 () none) ;; 149 ;; (process-drawable-reserved-method-149 () none 149)
|
|
(process-drawable-reserved-method-150 () none) ;; 150 ;; (process-drawable-reserved-method-150 () none 150)
|
|
(process-drawable-reserved-method-151 () none) ;; 151 ;; (process-drawable-reserved-method-151 () none 151)
|
|
(process-drawable-reserved-method-152 () none) ;; 152 ;; (process-drawable-reserved-method-152 () none 152)
|
|
(process-drawable-reserved-method-153 () none) ;; 153 ;; (process-drawable-reserved-method-153 () none 153)
|
|
(process-drawable-reserved-method-154 () none) ;; 154 ;; (process-drawable-reserved-method-154 () none 154)
|
|
(process-drawable-reserved-method-155 () none) ;; 155 ;; (process-drawable-reserved-method-155 () none 155)
|
|
(process-drawable-reserved-method-156 () none) ;; 156 ;; (process-drawable-reserved-method-156 () none 156)
|
|
(process-drawable-reserved-method-157 () none) ;; 157 ;; (process-drawable-reserved-method-157 () none 157)
|
|
(process-drawable-reserved-method-158 () none) ;; 158 ;; (process-drawable-reserved-method-158 () none 158)
|
|
(process-drawable-reserved-method-159 () none) ;; 159 ;; (process-drawable-reserved-method-159 () none 159)
|
|
(process-drawable-reserved-method-160 () none) ;; 160 ;; (process-drawable-reserved-method-160 () none 160)
|
|
(process-drawable-reserved-method-161 () none) ;; 161 ;; (process-drawable-reserved-method-161 () none 161)
|
|
(process-drawable-reserved-method-162 () none) ;; 162 ;; (process-drawable-reserved-method-162 () none 162)
|
|
(process-drawable-reserved-method-163 () none) ;; 163 ;; (process-drawable-reserved-method-163 () none 163)
|
|
(process-drawable-reserved-method-164 () none) ;; 164 ;; (process-drawable-reserved-method-164 () none 164)
|
|
(process-drawable-reserved-method-165 () none) ;; 165 ;; (process-drawable-reserved-method-165 () none 165)
|
|
(process-drawable-reserved-method-166 () none) ;; 166 ;; (process-drawable-reserved-method-166 () none 166)
|
|
(process-drawable-reserved-method-167 () none) ;; 167 ;; (process-drawable-reserved-method-167 () none 167)
|
|
(process-drawable-reserved-method-168 () none) ;; 168 ;; (process-drawable-reserved-method-168 () none 168)
|
|
(process-drawable-reserved-method-169 () none) ;; 169 ;; (process-drawable-reserved-method-169 () none 169)
|
|
(process-drawable-reserved-method-170 () none) ;; 170 ;; (process-drawable-reserved-method-170 () none 170)
|
|
(process-drawable-reserved-method-171 () none) ;; 171 ;; (process-drawable-reserved-method-171 () none 171)
|
|
(process-drawable-reserved-method-172 () none) ;; 172 ;; (process-drawable-reserved-method-172 () none 172)
|
|
(process-drawable-reserved-method-173 () none) ;; 173 ;; (process-drawable-reserved-method-173 () none 173)
|
|
(process-drawable-reserved-method-174 () none) ;; 174 ;; (process-drawable-reserved-method-174 () none 174)
|
|
(process-drawable-reserved-method-175 () none) ;; 175 ;; (process-drawable-reserved-method-175 () none 175)
|
|
(process-drawable-reserved-method-176 () none) ;; 176 ;; (process-drawable-reserved-method-176 () none 176)
|
|
(process-drawable-reserved-method-177 () none) ;; 177 ;; (process-drawable-reserved-method-177 () none 177)
|
|
(process-drawable-reserved-method-178 () none) ;; 178
|
|
(process-drawable-reserved-method-179 () none) ;; 179
|
|
(process-drawable-reserved-method-180 () none) ;; 180
|
|
(process-drawable-reserved-method-181 () none) ;; 181
|
|
(process-drawable-reserved-method-182 () none) ;; 182
|
|
(process-drawable-reserved-method-183 () none) ;; 183
|
|
(process-drawable-reserved-method-184 () none) ;; 184
|
|
(process-drawable-reserved-method-185 () none) ;; 185
|
|
(process-drawable-reserved-method-186 () none) ;; 186
|
|
(process-drawable-reserved-method-187 () none) ;; 187
|
|
(process-drawable-reserved-method-188 () none) ;; 188
|
|
(process-drawable-reserved-method-189 () none) ;; 189
|
|
(process-drawable-reserved-method-190 () none) ;; 190
|
|
(process-drawable-reserved-method-191 () none) ;; 191
|
|
(process-drawable-reserved-method-192 () none) ;; 192
|
|
(process-drawable-reserved-method-193 () none) ;; 193
|
|
(process-drawable-reserved-method-194 () none) ;; 194
|
|
(process-drawable-reserved-method-195 () none) ;; 195
|
|
(process-drawable-reserved-method-196 () none) ;; 196
|
|
(process-drawable-reserved-method-197 () none) ;; 197
|
|
(process-drawable-reserved-method-198 () none) ;; 198
|
|
(process-drawable-reserved-method-199 () none) ;; 199
|
|
(process-drawable-reserved-method-200 () none) ;; 200
|
|
(process-drawable-reserved-method-201 () none) ;; 201
|
|
(process-drawable-reserved-method-202 () none) ;; 202
|
|
(process-drawable-reserved-method-203 () none) ;; 203
|
|
(process-drawable-reserved-method-204 () none) ;; 204
|
|
(process-drawable-reserved-method-205 () none) ;; 205
|
|
(process-drawable-reserved-method-206 () none) ;; 206
|
|
(process-drawable-reserved-method-207 () none) ;; 207
|
|
(process-drawable-reserved-method-208 () none) ;; 208
|
|
(process-drawable-reserved-method-209 () none) ;; 209
|
|
(process-drawable-reserved-method-210 () none) ;; 210
|
|
(process-drawable-reserved-method-211 () none) ;; 211
|
|
(process-drawable-reserved-method-212 () none) ;; 212
|
|
(process-drawable-reserved-method-213 () none) ;; 213
|
|
(process-drawable-reserved-method-214 () none) ;; 214
|
|
(process-drawable-reserved-method-215 () none) ;; 215
|
|
(process-drawable-reserved-method-216 () none) ;; 216
|
|
(process-drawable-reserved-method-217 () none) ;; 217
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype attack-dir-info (structure)
|
|
((dir vector :inline :offset-assert 0)
|
|
(xz-dir vector :inline :offset-assert 16)
|
|
(attacker-velocity vector :inline :offset-assert 32)
|
|
(pos vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype attack-info (structure)
|
|
((trans vector :inline :offset-assert 0)
|
|
(vector vector :inline :offset-assert 16)
|
|
(attacker-velocity vector :inline :offset-assert 32)
|
|
(intersection vector :inline :offset-assert 48)
|
|
(attacker handle :offset-assert 64)
|
|
(attack-time uint64 :offset-assert 72) ;; time-frame
|
|
(invinc-time uint64 :offset-assert 80) ;; time-frame
|
|
(mask attack-info-mask :offset-assert 88) ;; attack-mask
|
|
(mode symbol :offset-assert 92) ;; guessed by decompiler
|
|
(shove-back meters :offset-assert 96)
|
|
(shove-up meters :offset-assert 100)
|
|
(speed meters :offset-assert 104)
|
|
(dist meters :offset-assert 108)
|
|
(control float :offset-assert 112)
|
|
(angle symbol :offset-assert 116) ;; guessed by decompiler
|
|
(rotate-to deg :offset-assert 120) ;; degrees
|
|
(prev-state state :offset-assert 124) ;; guessed by decompiler
|
|
(id uint32 :offset-assert 128)
|
|
(count uint32 :offset-assert 132)
|
|
(penetrate-using uint64 :offset-assert 136) ;; penetrate
|
|
(damage float :offset-assert 144)
|
|
(shield-damage float :offset-assert 148)
|
|
(vehicle-damage-factor float :offset-assert 152)
|
|
(vehicle-impulse-factor float :offset-assert 156)
|
|
(knock uint8 :offset-assert 160) ;; knocked-type
|
|
(test symbol :offset-assert 164) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #xa8
|
|
:flag-assert #xc000000a8
|
|
;; field handle is likely a value type.
|
|
(:methods
|
|
(attack-info-method-9 () none) ;; 9 ;; (attack-info-method-9 (_type_ attack-info process-drawable process-drawable) none 9)
|
|
(attack-info-method-10 () none) ;; 10 ;; (compute-intersect-info (_type_ object process-drawable process touching-shapes-entry) attack-info 10)
|
|
(attack-info-method-11 () none) ;; 11 ;; (combine! (_type_ attack-info process-drawable) attack-info 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ground-tween-info (structure)
|
|
((chan uint8 3 :offset-assert 0) ;; guessed by decompiler
|
|
(blend float 3 :offset-assert 4) ;; guessed by decompiler
|
|
(group uint32 5 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; text-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype game-text (structure)
|
|
((id text-id :offset-assert 0) ;; guessed by decompiler
|
|
(text string :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype game-text-info (basic)
|
|
((length int32 :offset-assert 4)
|
|
(language-id int32 :offset-assert 8)
|
|
(group-name string :offset-assert 12) ;; guessed by decompiler
|
|
(data game-text :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x10
|
|
:flag-assert #xa00000010
|
|
(:methods
|
|
(game-text-info-method-9 () none) ;; 9 ;; (lookup-text! (_type_ text-id symbol) string 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *text-group-names* array) ;; (array string)
|
|
;; (define-extern *common-text-heap* object) ;; kheap
|
|
;; (define-extern *common-text* object) ;; game-text-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; temple-obs2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tpl-gate (process-drawable)
|
|
((alt-actor basic :offset-assert 200)
|
|
(extra-id uint32 :offset-assert 204)
|
|
(perm uint32 :offset-assert 208)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xd4
|
|
:flag-assert #x1a006000d4
|
|
(:state-methods
|
|
idle ;; 20
|
|
open ;; 21
|
|
close ;; 22
|
|
closed ;; 23
|
|
opened ;; 24
|
|
die ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-watcher-manager (process)
|
|
((actor-group uint32 :offset-assert 124)
|
|
(actor-group-count int32 :offset-assert 128)
|
|
(within-outer-ring basic :offset-assert 132)
|
|
(within-inner-ring basic :offset-assert 136)
|
|
(ouched basic :offset-assert 140)
|
|
(bound-cam basic :offset-assert 144)
|
|
(trans vector :inline :offset-assert 156)
|
|
(state-time uint64 :offset-assert 172)
|
|
(jak-in-hint-region basic :offset-assert 180)
|
|
(watchers-vulnerable basic :offset-assert 184)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #xc0
|
|
:flag-assert #x11004000c0
|
|
(:state-methods
|
|
idle ;; 14
|
|
waiting ;; 15
|
|
until-watchers-dead ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-watcher (process-focusable)
|
|
((manager basic :offset-assert 208)
|
|
(bob-clock uint64 :offset-assert 216)
|
|
(period-a int32 :offset-assert 224)
|
|
(period-b int32 :offset-assert 228)
|
|
(laser-sight basic :offset-assert 232)
|
|
(laser-charge-fx basic :offset-assert 236)
|
|
(los los-control :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x194
|
|
:flag-assert #x2101200194
|
|
(:methods
|
|
(tpl-watcher-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
firing ;; 29
|
|
die ;; 30
|
|
standing-down ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-door-switch (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
down ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-door-a (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-door-b (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-spinning-plat (process-drawable)
|
|
((last-ridden uint64 :offset-assert 200)
|
|
(basal-trans vector :inline :offset-assert 208)
|
|
(no-collision-timer uint64 :offset-assert 224)
|
|
(attack-id int32 :offset-assert 232)
|
|
(my-sound uint32 :offset-assert 236)
|
|
(pitch-mod-hack float :offset-assert 240)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xf4
|
|
:flag-assert #x19008000f4
|
|
(:methods
|
|
(tpl-spinning-plat-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
flip ;; 21
|
|
desync ;; 20
|
|
wait ;; 22
|
|
underfoot ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-oracle-eye (process-drawable)
|
|
((leye-sparta basic :offset-assert 200)
|
|
(reye-sparta basic :offset-assert 204)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xd0
|
|
:flag-assert #x15005000d0
|
|
(:state-methods
|
|
open ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-banner-b (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-elevator (elevator)
|
|
()
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
(:state-methods
|
|
running ;; 37
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-banner (process-drawable)
|
|
((sound-id uint32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern shoot-at-jak function)
|
|
;; (define-extern tpl-watcher-manager-ehandler function)
|
|
;; (define-extern watcher-man-trans function)
|
|
;; (define-extern has-jak-visibility? function)
|
|
;; (define-extern *tpl-watcher-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern watcher-bob-trans function)
|
|
;; (define-extern already-down state)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bot-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bot-focus-info (structure)
|
|
((max-los-dist float :offset-assert 0)
|
|
(fproc process-focusable :offset-assert 4) ;; guessed by decompiler
|
|
(bullseye-xz-dist float :offset-assert 8)
|
|
(ry-diff float :offset-assert 12)
|
|
(my-facing-ry float :offset-assert 16)
|
|
(bullseye-ry float :offset-assert 20)
|
|
(los int8 :offset-assert 24)
|
|
(update-time uint64 :offset-assert 32) ;; time-frame
|
|
(bullseye vector :inline :offset-assert 48)
|
|
(pos vector :inline :offset-assert 64)
|
|
(my-facing-xz-dir vector :inline :offset-assert 80)
|
|
(bullseye-xz-dir vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-turn-info (structure)
|
|
((facing-ry float :offset-assert 0)
|
|
(targ-ry float :offset-assert 4)
|
|
(ry-diff float :offset-assert 8)
|
|
(predicted-ry-diff float :offset-assert 12)
|
|
(predicted-targ-ry float :offset-assert 16)
|
|
(facing-dir vector :inline :offset-assert 32)
|
|
(targ-pos vector :inline :offset-assert 48)
|
|
(predicted-targ-pos vector :inline :offset-assert 64)
|
|
(src-quat quaternion :inline :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-speech-tuning (structure)
|
|
((fo-min int32 :offset-assert 0)
|
|
(fo-max int32 :offset-assert 4)
|
|
(fo-curve int8 :offset-assert 8)
|
|
(trans? symbol :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-speech-info (structure)
|
|
((flags uint16 :offset-assert 0) ;; speech-flags
|
|
(hold-time uint16 :offset-assert 2)
|
|
(slave-id int8 :offset-assert 4)
|
|
(tuning-id int8 :offset-assert 5)
|
|
(name string :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-spot (structure)
|
|
((center vector :inline :offset-assert 0)
|
|
(center-x float :offset-assert 0)
|
|
(center-y float :offset-assert 4)
|
|
(center-z float :offset-assert 8)
|
|
(inside-xz-dist float :offset-assert 12)
|
|
(blocked-xz-dist float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-waypoint (basic)
|
|
((waypoint-id int16 :offset-assert 4)
|
|
(nav-mesh-index int8 :offset-assert 6)
|
|
(skip-to int8 :offset-assert 7)
|
|
(on-set (function bot none) :offset-assert 8) ;; guessed by decompiler
|
|
(on-update (function bot none) :offset-assert 12) ;; guessed by decompiler
|
|
(on-skipping-here (function bot none) :offset-assert 16) ;; guessed by decompiler
|
|
(check-too-far symbol :offset-assert 20) ;; guessed by decompiler
|
|
(warn-dist float :offset-assert 24)
|
|
(fail-dist-delta float :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
;; field check-too-far uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-course (basic)
|
|
((course-id uint8 :offset-assert 4)
|
|
(speech-count uint16 :offset-assert 6)
|
|
(spot-count uint16 :offset-assert 8)
|
|
(retry-cookie uint8 :offset-assert 10)
|
|
(too-far-warn-speeches bot-speech-list-shuffle :offset-assert 12) ;; guessed by decompiler
|
|
(too-far-fail-speeches bot-speech-list :offset-assert 16) ;; guessed by decompiler
|
|
(attack-player-speeches bot-speech-list :offset-assert 20) ;; guessed by decompiler
|
|
(default-check-too-far symbol :offset-assert 24) ;; guessed by decompiler
|
|
(waypoints (array bot-waypoint) :offset-assert 28) ;; guessed by decompiler
|
|
(speeches (inline-array bot-speech-info) :offset-assert 32) ;; guessed by decompiler
|
|
(speech-tunings (inline-array bot-speech-tuning) :offset-assert 36) ;; guessed by decompiler
|
|
(dirs (inline-array vector) :offset-assert 40) ;; guessed by decompiler
|
|
(spots (inline-array bot-spot) :offset-assert 44) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
;; field default-check-too-far uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot (nav-enemy)
|
|
((bot-flags bot-flags :offset-assert 620) ;; guessed by decompiler
|
|
(min-speed float :offset-assert 624)
|
|
(max-speed float :offset-assert 628)
|
|
(follow-offset float :offset-assert 632)
|
|
(too-far-warn-dist float :offset-assert 636)
|
|
(too-far-fail-dist-delta float :offset-assert 640)
|
|
(too-far-warn-dist-default float :offset-assert 644)
|
|
(too-far-fail-dist-delta-default float :offset-assert 648)
|
|
(travel-prev-ry float :offset-assert 652)
|
|
(travel-prev-ry1 float :offset-assert 656)
|
|
(player-blocking float :offset-assert 660)
|
|
(ai-ctrl ai-task-control :offset-assert 664) ;; guessed by decompiler
|
|
(course bot-course :offset-assert 668) ;; guessed by decompiler
|
|
(waypoint bot-waypoint :offset-assert 672) ;; guessed by decompiler
|
|
(waypoint-bits waypoint-bits :offset-assert 676) ;; guessed by decompiler
|
|
(waypoint-int32a int32 :offset-assert 680)
|
|
(bot-task-bits bot-task-bits :offset-assert 684) ;; guessed by decompiler
|
|
(hit-invuln-ignore-me-delay uint32 :offset-assert 688)
|
|
(hit-invuln-focus-disable-delay uint32 :offset-assert 692)
|
|
(warn-to-fail-timeout uint32 :offset-assert 696)
|
|
(warn-min-delay uint32 :offset-assert 700)
|
|
(warn-max-delay uint32 :offset-assert 704)
|
|
(spot-color uint32 :offset-assert 708)
|
|
(waypoint-request int16 :offset-assert 712)
|
|
(hit-by-enemy-count uint16 :offset-assert 714)
|
|
(hit-by-player-count uint16 :offset-assert 716)
|
|
(notice-enemy-dist float :offset-assert 720)
|
|
(channel uint8 :offset-assert 724) ;; gui-channel
|
|
(focus-mode int8 :offset-assert 725)
|
|
(nav-mesh-index int8 :offset-assert 726)
|
|
(delay-too-far-check int8 :offset-assert 727)
|
|
(slave-id int8 :offset-assert 728)
|
|
(vehicle-seat-index int8 :offset-assert 729)
|
|
(bot-health-index int8 :offset-assert 730)
|
|
(task game-task-control :offset-assert 732) ;; guessed by decompiler
|
|
(task-node basic :offset-assert 736)
|
|
(swivel-joint-mod joint-mod :offset-assert 740) ;; guessed by decompiler
|
|
(health-handle uint64 :offset-assert 744) ;; handle
|
|
(poi-handle uint64 :offset-assert 752) ;; handle
|
|
(my-simple-focus (pointer simple-focus) :offset-assert 760) ;; guessed by decompiler
|
|
(attacker-handle uint64 :offset-assert 768) ;; handle
|
|
(scene-player-handle uint64 :offset-assert 776) ;; handle
|
|
(master-handle uint64 :offset-assert 784) ;; handle
|
|
(vehicle-handle uint64 :offset-assert 792) ;; handle
|
|
(hit-invuln-starting-time uint64 :offset-assert 800) ;; time-frame
|
|
(danger-time uint64 :offset-assert 808) ;; time-frame
|
|
(attacker-time uint64 :offset-assert 816) ;; time-frame
|
|
(started-warning-time uint64 :offset-assert 824) ;; time-frame
|
|
(waypoint-time0 uint64 :offset-assert 832) ;; time-frame
|
|
(next-too-far-warn-time uint64 :offset-assert 840) ;; time-frame
|
|
(spot bot-spot :inline :offset-assert 848)
|
|
(follow-dir vector :inline :offset-assert 880)
|
|
(focus-info bot-focus-info :inline :offset-assert 896)
|
|
)
|
|
:method-count-assert 237
|
|
:size-assert #x3f0
|
|
:flag-assert #xed037003f0
|
|
(:methods
|
|
(bot-method-190 () none) ;; 190 ;; (bot-method-190 (_type_) symbol 190)
|
|
(bot-method-191 () none) ;; 191 ;; (bot-method-191 (_type_) none 191)
|
|
(bot-method-192 () none) ;; 192 ;; (bot-method-192 (_type_) none 192)
|
|
(bot-method-193 () none) ;; 193 ;; (bot-method-193 (_type_) symbol 193)
|
|
(bot-method-194 () none) ;; 194 ;; (outside-spot-radius? (_type_ bot-spot vector symbol) symbol 194)
|
|
(bot-method-195 () none) ;; 195 ;; (attacked-by-player? (_type_ process-focusable) symbol 195)
|
|
(bot-method-196 () none) ;; 196 ;; (bot-method-196 (_type_) none 196)
|
|
(bot-method-197 () none) ;; 197 ;; (fail-mission! (_type_) none 197)
|
|
(bot-method-198 () none) ;; 198 ;; (set-cam-height! (_type_ vector) meters 198)
|
|
(bot-method-199 () none) ;; 199 ;; (cam-move-to-bot (_type_) none 199)
|
|
(bot-method-200 () none) ;; 200 ;; (fail-falling (_type_) none 200)
|
|
(bot-method-201 () none) ;; 201 ;; (set-next-focus! (_type_ enemy enemy-best-focus) none 201)
|
|
(bot-method-202 () none) ;; 202 ;; (choose-spot (_type_ int (pointer uint)) int 202)
|
|
(bot-method-203 () none) ;; 203 ;; (play-attacked-speech (_type_) none 203)
|
|
(bot-method-204 () none) ;; 204 ;; (play-too-far-warn-speech (_type_) symbol 204)
|
|
(bot-method-205 () none) ;; 205 ;; (scene-play (_type_ string symbol) symbol 205)
|
|
(bot-method-206 () none) ;; 206 ;; (play-speech (_type_ int) none 206)
|
|
(bot-method-207 () none) ;; 207 ;; (play-death-sound (_type_ string) none 207)
|
|
(bot-method-208 () none) ;; 208 ;; (bot-method-208 (_type_) symbol 208)
|
|
(bot-method-209 () none) ;; 209 ;; (channel-active? (_type_ gui-channel) symbol 209)
|
|
(bot-method-210 () none) ;; 210 ;; (init! (_type_) none 210)
|
|
(bot-method-211 () none) ;; 211 ;; (clear-speech-flags! (_type_) none 211)
|
|
(bot-method-212 () none) ;; 212 ;; (reset-warn-time! (_type_) none 212)
|
|
(bot-method-213 () none) ;; 213 ;; (go-to-waypoint! (_type_ int symbol) object 213)
|
|
(bot-method-214 () none) ;; 214 ;; (bot-method-214 (_type_) symbol 214)
|
|
(bot-method-215 () none) ;; 215 ;; (skip-waypoint (_type_) object 215)
|
|
(bot-method-216 () none) ;; 216 ;; (bot-method-216 (_type_) none 216)
|
|
(bot-method-217 () none) ;; 217 ;; (speech-ended? (_type_ int) symbol 217)
|
|
(bot-method-218 () none) ;; 218 ;; (speech-playing? (_type_ int) symbol 218)
|
|
(bot-method-219 () none) ;; 219 ;; (player-blocking-spot? (_type_ bot-spot) symbol 219)
|
|
(bot-method-220 () none) ;; 220 ;; (stop-speech (_type_ uint symbol) none 220)
|
|
(bot-method-221 () none) ;; 221 ;; (bot-method-221 (_type_) quaternion 221)
|
|
(bot-method-222 () none) ;; 222 ;; (bot-method-222 (_type_ vector) none 222)
|
|
(bot-method-223 () none) ;; 223 ;; (bot-method-223 (_type_ symbol) none 223)
|
|
(bot-method-224 () none) ;; 224 ;; (bot-check-too-far (_type_) symbol 224)
|
|
(bot-method-225 () none) ;; 225
|
|
(bot-method-226 () none) ;; 226
|
|
(bot-method-227 () none) ;; 227
|
|
(bot-method-228 () none) ;; 228
|
|
(bot-method-229 () none) ;; 229
|
|
(bot-method-230 () none) ;; 230
|
|
(bot-method-231 () none) ;; 231
|
|
(bot-method-232 () none) ;; 232
|
|
(bot-method-233 () none) ;; 233
|
|
(bot-method-234 () none) ;; 234
|
|
(bot-method-235 () none) ;; 235
|
|
(bot-method-236 () none) ;; 236
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-speech-list (basic)
|
|
((flags uint8 :offset-assert 4)
|
|
(retry-cookie uint8 :offset-assert 5)
|
|
(last-local-index int16 :offset-assert 6)
|
|
(speech-indexes (array int16) :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #xc
|
|
:flag-assert #xb0000000c
|
|
(:methods
|
|
(bot-speech-list-method-9 () none) ;; 9 ;; (bot-speech-list-method-9 (_type_ bot (inline-array bot-speech-info) speech-flags) int 9)
|
|
(bot-speech-list-method-10 () none) ;; 10 ;; (reset-index (_type_ symbol) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-speech-list-shuffle (bot-speech-list)
|
|
((history-mask uint64 :offset-assert 16)
|
|
(history-mask-full uint64 :offset-assert 24)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x20
|
|
:flag-assert #xb00000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bot-course-table (basic)
|
|
((course bot-course 1 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *bot-task-pool* ai-task-pool) ;; ai-task-pool
|
|
;; (define-extern *bot-course-table* bot-course-table) ;; bot-course-table
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mood-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mood-channel (structure)
|
|
((data float 24 :offset-assert 0) ;; guessed by decompiler
|
|
(vecs vector4 6 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-channel-group (structure)
|
|
((data mood-channel 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x180
|
|
:flag-assert #x900000180
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-fog (structure)
|
|
((fog-color vector :inline :offset-assert 0)
|
|
(fog-dists vector :inline :offset-assert 16)
|
|
(fog-start meters :offset-assert 16)
|
|
(fog-end meters :offset-assert 20)
|
|
(fog-max float :offset-assert 24)
|
|
(fog-min float :offset-assert 28)
|
|
(erase-color vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-fog-table (structure)
|
|
((data mood-fog 8 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x180
|
|
:flag-assert #x900000180
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-color (structure)
|
|
((lgt-color vector :inline :offset-assert 0)
|
|
(amb-color vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-direction-table (structure)
|
|
((data vector 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-color-table (structure)
|
|
((data mood-color 8 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x100
|
|
:flag-assert #x900000100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-sky-table (structure)
|
|
((data vector 8 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-clouds (structure)
|
|
((cloud-min float :offset-assert 0)
|
|
(cloud-max float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-weather (structure)
|
|
((data float 2 :offset-assert 0) ;; guessed by decompiler
|
|
(cloud float :offset-assert 0)
|
|
(fog float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-iweather (structure)
|
|
((data int32 2 :offset-assert 0) ;; guessed by decompiler
|
|
(cloud int32 :offset-assert 0)
|
|
(fog int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-range (structure)
|
|
((data float 4 :offset-assert 0) ;; guessed by decompiler
|
|
(min-cloud float :offset-assert 0)
|
|
(max-cloud float :offset-assert 4)
|
|
(min-fog float :offset-assert 8)
|
|
(max-fog float :offset-assert 12)
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-filters-table (structure)
|
|
((data vector 8 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-table (basic)
|
|
((mood-fog-table mood-fog-table :offset-assert 4)
|
|
(mood-color-table mood-color-table :offset-assert 8)
|
|
(mood-channel-group mood-channel-group :offset-assert 12)
|
|
(mood-direction-table mood-direction-table :offset-assert 16)
|
|
(mood-sky-table mood-sky-table :offset-assert 20)
|
|
(mood-interp-table sky-color-day :offset-assert 24) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-state (structure)
|
|
((time float :offset-assert 0)
|
|
(fade float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flicker-state (structure)
|
|
((flicker-off uint8 :offset-assert 0)
|
|
(flicker-on uint8 :offset-assert 1)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype florescent-state (structure)
|
|
((value float :offset-assert 0)
|
|
(delay int8 :offset-assert 4)
|
|
(delay2 int8 :offset-assert 5)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype electricity-state (structure)
|
|
((value float :offset-assert 0)
|
|
(scale float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pulse-state (structure)
|
|
((pulse float :offset-assert 0)
|
|
(brightness float :offset-assert 4)
|
|
(target-brightness float :offset-assert 8)
|
|
(speed float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype strobe-state (structure)
|
|
((time float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flames-state (structure)
|
|
((time float :offset-assert 0)
|
|
(index uint8 :offset-assert 4)
|
|
(length uint8 :offset-assert 5)
|
|
(height uint8 :offset-assert 6)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x7
|
|
:flag-assert #x900000007
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-context-core (structure)
|
|
((current-fog mood-fog :inline :offset-assert 0)
|
|
(current-sky-color vector :inline :offset-assert 48)
|
|
(current-env-color vector :inline :offset-assert 64)
|
|
(current-prt-color vector :inline :offset-assert 80)
|
|
(current-shadow-color vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-context-core2 (mood-context-core)
|
|
((light-group light-group 8 :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x670
|
|
:flag-assert #x900000670
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-context-core3 (mood-context-core2)
|
|
((times vector 8 :offset-assert 1648) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6f0
|
|
:flag-assert #x9000006f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-context (mood-context-core3)
|
|
((itimes vector4w 4 :offset-assert 1776) ;; guessed by decompiler
|
|
(state uint32 32 :offset-assert 1840) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x7b0
|
|
:flag-assert #x9000007b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-control-work (structure)
|
|
((color vector4w :inline :offset-assert 0)
|
|
(weather mood-weather :inline :offset-assert 16)
|
|
(iweather mood-iweather :inline :offset-assert 24)
|
|
(interp mood-weather :inline :offset-assert 32)
|
|
(index int32 4 :offset-assert 40) ;; guessed by decompiler
|
|
(color-interp float :offset-assert 56)
|
|
(color-index int32 2 :offset-assert 60) ;; guessed by decompiler
|
|
(channel-interp float :offset-assert 68)
|
|
(channel-index int32 2 :offset-assert 72) ;; guessed by decompiler
|
|
(cloud-interp float :offset-assert 80)
|
|
(cloud-index int32 2 :offset-assert 84) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5c
|
|
:flag-assert #x90000005c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mood-control (mood-table)
|
|
((mood-clouds mood-clouds :offset-assert 28)
|
|
(current-interp mood-weather :inline :offset-assert 32)
|
|
(target-interp mood-weather :inline :offset-assert 40)
|
|
(speed-interp mood-weather :inline :offset-assert 48)
|
|
(range mood-range :inline :offset-assert 64)
|
|
(time-until-random mood-weather :inline :offset-assert 80)
|
|
(time-until-random-min mood-weather :inline :offset-assert 88)
|
|
(time-until-random-max mood-weather :inline :offset-assert 96)
|
|
(current-special-interp float :offset-assert 104)
|
|
(target-special-interp float :offset-assert 108)
|
|
(rate-special-interp float :offset-assert 112)
|
|
(display-flag symbol :offset-assert 116) ;; guessed by decompiler
|
|
(overide-weather-flag symbol :offset-assert 120) ;; guessed by decompiler
|
|
(overide mood-weather :inline :offset-assert 128)
|
|
(lightning-index int32 :offset-assert 136)
|
|
(lightning-val int32 :offset-assert 140)
|
|
(lightning-time int32 :offset-assert 144)
|
|
(lightning-time2 float :offset-assert 148)
|
|
(lightning-time3 float :offset-assert 152)
|
|
(lightning-flash float :offset-assert 156)
|
|
(lightning-id sound-id :offset-assert 160) ;; guessed by decompiler
|
|
(lightning-count0 uint32 :offset-assert 164)
|
|
(lightning-count1 uint32 :offset-assert 168)
|
|
(lightning-count2 uint32 :offset-assert 172)
|
|
(rain-id sound-id :offset-assert 176) ;; guessed by decompiler
|
|
(sound-pitch float :offset-assert 180)
|
|
(fogs mood-fog-table 9 :offset-assert 184) ;; guessed by decompiler
|
|
(colors mood-color-table 3 :offset-assert 220) ;; guessed by decompiler
|
|
(channels mood-channel-group 3 :offset-assert 232) ;; guessed by decompiler
|
|
(clouds mood-clouds 9 :offset-assert 244) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x118
|
|
:flag-assert #x1900000118
|
|
(:methods
|
|
(mood-control-method-9 () none) ;; 9 ;; (init-weather! (_type_) none 9)
|
|
(mood-control-method-10 () none) ;; 10 ;; (update-mood-weather! (_type_ float float float float) none 10)
|
|
(mood-control-method-11 () none) ;; 11 ;; (update-mood-range! (_type_ float float float float) none 11)
|
|
(mood-control-method-12 () none) ;; 12 ;; (set-time-for-random-weather! (_type_ float float) none 12)
|
|
(mood-control-method-13 () none) ;; 13 ;; (apply-mood-clouds-and-fog (_type_ mood-control-work) none 13)
|
|
(mood-control-method-14 () none) ;; 14 ;; (apply-mood-color (_type_ mood-control-work) none 14)
|
|
(mood-control-method-15 () none) ;; 15 ;; (apply-mood-channels (_type_ mood-control-work) none 15)
|
|
(mood-control-method-16 () none) ;; 16 ;; (adjust-num-clouds! (_type_ mood-control-work) none 16)
|
|
(mood-control-method-17 () none) ;; 17 ;; (gen-lightning-and-thunder! (_type_) number 17)
|
|
(mood-control-method-18 () none) ;; 18 ;; (play-or-stop-lightning! (_type_ sound-spec vector) sound-id 18)
|
|
(mood-control-method-19 () none) ;; 19
|
|
(mood-control-method-20 () none) ;; 20
|
|
(mood-control-method-21 () none) ;; 21
|
|
(mood-control-method-22 () none) ;; 22
|
|
(mood-control-method-23 () none) ;; 23
|
|
(mood-control-method-24 () none) ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fac-gunturret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fac-gun-tower-turret-params (structure)
|
|
((normal-sg basic :offset-assert 0)
|
|
(explode-sg basic :offset-assert 4)
|
|
(enemy-info basic :offset-assert 8)
|
|
(idle-anim int32 :offset-assert 12)
|
|
(shoot-anim int32 :offset-assert 16)
|
|
(track-joint int32 :offset-assert 20)
|
|
(left-barrel-joint int32 :offset-assert 24)
|
|
(right-barrel-joint int32 :offset-assert 28)
|
|
(left-gun-joint int32 :offset-assert 32)
|
|
(right-gun-joint int32 :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-gunturret (enemy)
|
|
((left-gun-tilt-jm basic :offset-assert 552)
|
|
(right-gun-tilt-jm basic :offset-assert 556)
|
|
(params fac-gun-tower-turret-params :offset-assert 560)
|
|
(aim-pos vector :inline :offset-assert 576)
|
|
(gun-twist float :offset-assert 592)
|
|
(gun-tilt float :offset-assert 596)
|
|
(desired-twist float :offset-assert 600)
|
|
(desired-tilt float :offset-assert 604)
|
|
(los-clear basic :offset-assert 608)
|
|
(smoke-part basic :offset-assert 612)
|
|
(casing-part basic :offset-assert 616)
|
|
(flash-state basic :offset-assert 620)
|
|
(can-shoot basic :offset-assert 624)
|
|
(last-hit-time uint64 :offset-assert 632)
|
|
(init-mat matrix :inline :offset-assert 640)
|
|
(activate-distance float :offset-assert 704)
|
|
(aim-offset vector :inline :offset-assert 720)
|
|
(use-alt-barrel basic :offset-assert 736)
|
|
(rotate-sound uint32 :offset-assert 740)
|
|
(rotate-sound-playing basic :offset-assert 744)
|
|
(snd-cmd-time uint64 :offset-assert 752)
|
|
)
|
|
:method-count-assert 161
|
|
:size-assert #x2f8
|
|
:flag-assert #xa1028002f8
|
|
(:methods
|
|
(fac-gunturret-method-155 () none) ;; 155
|
|
(fac-gunturret-method-156 () none) ;; 156
|
|
(fac-gunturret-method-157 () none) ;; 157
|
|
(fac-gunturret-method-158 () none) ;; 158
|
|
(fac-gunturret-method-159 () none) ;; 159
|
|
(fac-gunturret-method-160 () none) ;; 160
|
|
)
|
|
(:state-methods
|
|
hostile ;; 38
|
|
stare ;; 37
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-gun-tower-turret (fac-gunturret)
|
|
()
|
|
:method-count-assert 161
|
|
:size-assert #x2f8
|
|
:flag-assert #xa1028002f8
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fac-gunturret-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *fac-gunturret-enemy-info* enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; level-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype level-vis-info (basic)
|
|
((level level :offset-assert 4) ;; guessed by decompiler
|
|
(from-level symbol :offset-assert 8) ;; guessed by decompiler
|
|
(from-bsp bsp-header :offset-assert 12) ;; guessed by decompiler
|
|
(flags vis-info-flag :offset-assert 16)
|
|
(length uint32 :offset-assert 20)
|
|
(allocated-length uint32 :offset-assert 24)
|
|
(dictionary-length uint32 :offset-assert 28)
|
|
(dictionary uint32 :offset-assert 32)
|
|
(string-block uint32 :offset-assert 36)
|
|
(ramdisk uint32 :offset-assert 40)
|
|
(vis-bits uint32 :offset-assert 44)
|
|
(current-vis-string uint32 :offset-assert 48)
|
|
(vis-string uint32 :dynamic :offset-assert 52) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype level-borrow-info (basic)
|
|
((alias basic :offset-assert 4)
|
|
(borrow-size UNKNOWN 5 :offset-assert 8)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(borrow-info UNKNOWN 5 :offset-assert 20)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype level-load-info (basic)
|
|
((name-list symbol 6 :offset-assert 4) ;; guessed by decompiler
|
|
(name symbol :offset-assert 4) ;; guessed by decompiler
|
|
(visname symbol :offset-assert 8) ;; guessed by decompiler
|
|
(nickname symbol :offset-assert 12) ;; guessed by decompiler
|
|
(dbname symbol :offset-assert 16) ;; guessed by decompiler
|
|
(taskname symbol :offset-assert 20) ;; guessed by decompiler
|
|
(index int16 :offset-assert 28)
|
|
(task-level uint8 :offset-assert 30)
|
|
(part-engine-max uint8 :offset-assert 31) ;; int32
|
|
(master-level basic :offset-assert 32)
|
|
(level-flags uint32 :offset-assert 36)
|
|
(packages pair :offset-assert 40) ;; guessed by decompiler
|
|
(run-packages pair :offset-assert 44) ;; guessed by decompiler
|
|
(memory-mode load-buffer-mode :offset-assert 48) ;; guessed by decompiler
|
|
(music-bank symbol :offset-assert 52) ;; guessed by decompiler
|
|
(sound-reverb float :offset-assert 56)
|
|
(extra-sound-bank pair :offset-assert 60) ;; guessed by decompiler
|
|
(mood-func symbol :offset-assert 64) ;; guessed by decompiler
|
|
(special-mood basic :offset-assert 68)
|
|
(ocean symbol :offset-assert 72) ;; guessed by decompiler
|
|
(ocean-height float :offset-assert 76)
|
|
(ocean-alpha float :offset-assert 80)
|
|
(status-cache uint16 :offset-assert 84)
|
|
(status-cache-sync uint16 :offset-assert 86)
|
|
(priority int32 :offset-assert 88)
|
|
(draw-priority float :offset-assert 92)
|
|
(base-task-mask task-mask :offset-assert 96)
|
|
(buffer-size uint32 :offset-assert 100)
|
|
(city-map-bits uint64 :offset-assert 104)
|
|
(bigmap-id bigmap-id :offset-assert 112) ;; guessed by decompiler
|
|
(continues pair :offset-assert 116) ;; guessed by decompiler
|
|
(callback-list basic :offset-assert 120)
|
|
(borrow basic :offset-assert 124)
|
|
(bottom-height meters :offset-assert 128)
|
|
(fog-height float :offset-assert 132)
|
|
(max-rain float :offset-assert 136)
|
|
(fog-mult float :offset-assert 140)
|
|
(mood-range mood-range :inline :offset-assert 144)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #xa0
|
|
:flag-assert #xb000000a0
|
|
;; field extra-sound-bank uses ~A with a signed load.
|
|
(:methods
|
|
(level-load-info-method-9 () none) ;; 9
|
|
(level-load-info-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype login-state (basic)
|
|
((state int32 :offset-assert 4)
|
|
(pos uint32 :offset-assert 8)
|
|
(elts uint32 :offset-assert 12)
|
|
(elt drawable 16 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype level (basic)
|
|
((name symbol :offset-assert 4) ;; guessed by decompiler
|
|
(load-name symbol :offset-assert 8) ;; guessed by decompiler
|
|
(nickname symbol :offset-assert 12) ;; guessed by decompiler
|
|
(index int32 :offset-assert 16)
|
|
(status symbol :offset-assert 20) ;; guessed by decompiler
|
|
(borrow-level level 5 :offset-assert 24) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(borrow-from-level level :offset-assert 44) ;; guessed by decompiler
|
|
(heap kheap :inline :offset-assert 48)
|
|
(borrow-heap kheap 5 :offset-assert 64) ;; guessed by decompiler
|
|
(bsp bsp-header :offset-assert 144) ;; guessed by decompiler
|
|
(art-group load-dir-art-group :offset-assert 148) ;; guessed by decompiler
|
|
(info level-load-info :offset-assert 152) ;; guessed by decompiler
|
|
(texture-page texture-page 20 :offset-assert 156) ;; guessed by decompiler
|
|
(loaded-texture-page texture-page 16 :offset-assert 236) ;; guessed by decompiler
|
|
(loaded-texture-page-count int32 :offset-assert 300)
|
|
(entity entity-links-array :offset-assert 304) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(upload-size int32 20 :offset-assert 388) ;; guessed by decompiler
|
|
(inside-boxes? basic :offset-assert 468)
|
|
(display? symbol :offset-assert 472) ;; guessed by decompiler
|
|
(render? symbol :offset-assert 476) ;; guessed by decompiler
|
|
(meta-inside? symbol :offset-assert 480) ;; guessed by decompiler
|
|
(force-inside? symbol :offset-assert 484) ;; guessed by decompiler
|
|
(load-id uint32 :offset-assert 488)
|
|
(mood-context mood-context :inline :offset-assert 496)
|
|
(mood-func (function mood-context float int none) :offset-assert 2464) ;; guessed by decompiler
|
|
(mood-init (function mood-context none) :offset-assert 2468) ;; guessed by decompiler
|
|
(vis-bits pointer :offset-assert 2472) ;; guessed by decompiler
|
|
(all-visible? symbol :offset-assert 2476) ;; guessed by decompiler
|
|
(force-all-visible? symbol :offset-assert 2480) ;; guessed by decompiler
|
|
(linking symbol :offset-assert 2484) ;; guessed by decompiler
|
|
(vis-info level-vis-info 8 :offset-assert 2488) ;; guessed by decompiler
|
|
(vis-self-index int32 :offset-assert 2520)
|
|
(vis-adj-index int32 :offset-assert 2524)
|
|
(vis-buffer uint8 2048 :offset-assert 2528) ;; guessed by decompiler
|
|
(mem-usage-block memory-usage-block :offset-assert 4576) ;; guessed by decompiler
|
|
(mem-usage int32 :offset-assert 4580)
|
|
(code-memory-start pointer :offset-assert 4584) ;; guessed by decompiler
|
|
(code-memory-end pointer :offset-assert 4588) ;; guessed by decompiler
|
|
(load-start-time uint64 :offset-assert 4592) ;; time-frame
|
|
(load-stop-time uint64 :offset-assert 4600) ;; time-frame
|
|
(load-buffer uint32 2 :offset-assert 4608) ;; guessed by decompiler
|
|
(load-buffer-size uint32 :offset-assert 4616)
|
|
(load-buffer-last dgo-header :offset-assert 4620) ;; uint32
|
|
(load-buffer-mode load-buffer-mode :offset-assert 4624) ;; guessed by decompiler
|
|
(display-start-time uint64 :offset-assert 4632) ;; time-frame
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(task-mask task-mask :offset-assert 4644)
|
|
(tfrag-gs-test uint64 :offset-assert 4648) ;; gs-test
|
|
(texture-dirty-masks texture-mask 11 :offset-assert 4656) ;; guessed by decompiler
|
|
(texture-mask texture-mask 20 :offset-assert 4832) ;; guessed by decompiler
|
|
(sky-mask texture-mask :inline :offset-assert 5152)
|
|
(tfrag-masks texture-masks-array :offset-assert 5168) ;; guessed by decompiler
|
|
(tfrag-dists pointer :offset-assert 5172) ;; guessed by decompiler
|
|
(shrub-masks texture-masks-array :offset-assert 5176) ;; guessed by decompiler
|
|
(shrub-dists pointer :offset-assert 5180) ;; guessed by decompiler
|
|
(alpha-masks texture-masks-array :offset-assert 5184) ;; guessed by decompiler
|
|
(alpha-dists pointer :offset-assert 5188) ;; guessed by decompiler
|
|
(water-masks texture-masks-array :offset-assert 5192) ;; guessed by decompiler
|
|
(water-dists pointer :offset-assert 5196) ;; guessed by decompiler
|
|
(tfrag-last-calls int32 6 :offset-assert 5200) ;; guessed by decompiler
|
|
(texture-anim-array texture-anim-array 11 :offset-assert 5224) ;; guessed by decompiler
|
|
(light-hash light-hash :offset-assert 5268) ;; guessed by decompiler
|
|
(draw-priority float :offset-assert 5272)
|
|
(draw-index int32 :offset-assert 5276)
|
|
(part-engine engine :offset-assert 5280) ;; guessed by decompiler
|
|
(user-object basic 4 :offset-assert 5284) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(loaded-text-info-count int32 :offset-assert 5300)
|
|
(loaded-text-info game-text-info 16 :offset-assert 5304) ;; guessed by decompiler
|
|
(level-type type :offset-assert 5368) ;; guessed by decompiler
|
|
(load-order uint64 :offset-assert 5376) ;; int64
|
|
(eye-slot-lowres UNKNOWN 11 :offset-assert 5384)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(eye-slot-highres UNKNOWN 11 :offset-assert 5395)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x152c
|
|
:flag-assert #x1e0000152c
|
|
(:methods
|
|
(level-method-9 () none) ;; 9 ;; (deactivate (_type_) _type_ 9)
|
|
(level-method-10 () none) ;; 10 ;; (is-object-visible? (_type_ int) symbol 10)
|
|
(level-method-11 () none) ;; 11 ;; (level-method-11 () none 11)
|
|
(level-method-12 () none) ;; 12 ;; (unload! (_type_) _type_ 12)
|
|
(level-method-13 () none) ;; 13 ;; (bsp-name (_type_) symbol 13)
|
|
(level-method-14 () none) ;; 14 ;; (compute-memory-usage! (_type_ symbol) memory-usage-block 14)
|
|
(level-method-15 () none) ;; 15 ;; (inside-boxes-check (_type_ vector) symbol 15)
|
|
(level-method-16 () none) ;; 16 ;; (update-vis! (_type_ level-vis-info uint (pointer uint8)) symbol 16)
|
|
(level-method-17 () none) ;; 17 ;; (load-continue (_type_) _type_ 17)
|
|
(level-method-18 () none) ;; 18 ;; (load-begin (_type_) _type_ 18)
|
|
(level-method-19 () none) ;; 19 ;; (login-begin (_type_) _type_ 19)
|
|
(level-method-20 () none) ;; 20 ;; (debug-print-region-splitbox (_type_ vector object) none 20)
|
|
(level-method-21 () none) ;; 21 ;; (get-art-group-by-name (_type_ string) art-group 21)
|
|
(level-method-22 () none) ;; 22 ;; (level-method-22 (_type_ symbol) int 22)
|
|
(level-method-23 () none) ;; 23 ;; (lookup-text (_type_ text-id symbol) string 23)
|
|
(level-method-24 () none) ;; 24 ;; (level-method-24 () none 24)
|
|
(level-method-25 () none) ;; 25 ;; (birth (_type_) _type_ 25)
|
|
(level-method-26 () none) ;; 26 ;; (level-status-update! (_type_ symbol) _type_ 26)
|
|
(level-method-27 () none) ;; 27 ;; (load-required-packages (_type_) _type_ 27)
|
|
(level-method-28 () none) ;; 28 ;; (init-vis-from-bsp (_type_) none 28)
|
|
(level-method-29 () none) ;; 29 ;; (vis-clear (_type_) none 29)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype level-group (basic)
|
|
((length int32 :offset-assert 4)
|
|
(entity-link entity-links :offset-assert 16)
|
|
(border? symbol :offset-assert 20) ;; guessed by decompiler
|
|
(vis? symbol :offset-assert 24) ;; guessed by decompiler
|
|
(want-level basic :offset-assert 28)
|
|
(receiving-level basic :offset-assert 32)
|
|
(load-commands pair :offset-assert 36) ;; guessed by decompiler
|
|
(play? symbol :offset-assert 40) ;; guessed by decompiler
|
|
(target-pos vector 2 :offset-assert 48) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(camera-pos vector 2 :offset-assert 80) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(heap kheap :inline :offset-assert 112)
|
|
(sound-bank basic 6 :offset-assert 128) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(disk-load-timing? symbol :offset-assert 176) ;; guessed by decompiler
|
|
(load-level symbol :offset-assert 180) ;; guessed by decompiler
|
|
(load-size uint32 :offset-assert 184)
|
|
(load-time float :offset-assert 188)
|
|
(load-login-time float :offset-assert 192)
|
|
(draw-level-count int32 :offset-assert 196)
|
|
(draw-level level 11 :offset-assert 200) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(draw-index-map uint8 11 :offset-assert 244) ;; guessed by decompiler
|
|
(status-cache-sync uint16 :offset-assert 256)
|
|
(load-order uint64 :offset-assert 264)
|
|
(level level 11 :offset-assert 324) ;; guessed by decompiler
|
|
(data UNKNOWN 11 :offset-assert 324)
|
|
(level0 level :inline :offset-assert 324)
|
|
(level1 level :inline :offset-assert 5748)
|
|
(level2 level :inline :offset-assert 11172)
|
|
(level3 level :inline :offset-assert 16596)
|
|
(level4 level :inline :offset-assert 22020)
|
|
(level5 level :inline :offset-assert 27444)
|
|
(level6 level :inline :offset-assert 4)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #xea54
|
|
:flag-assert #x1f0000ea54
|
|
;; Failed to read some fields.
|
|
(:methods
|
|
(level-group-method-9 () none) ;; 9 ;; (level-get (_type_ symbol) level 9)
|
|
(level-group-method-10 () none) ;; 10 ;; (level-get-with-status (_type_ symbol) level 10)
|
|
(level-group-method-11 () none) ;; 11 ;; (get-level-by-heap-ptr-and-status (_type_ pointer symbol) level 11)
|
|
(level-group-method-12 () none) ;; 12 ;; (level-get-for-use (_type_ symbol symbol) level 12)
|
|
(level-group-method-13 () none) ;; 13 ;; (activate-levels! (_type_) int 13)
|
|
(level-group-method-14 () none) ;; 14 ;; (debug-print-entities (_type_ symbol type) none 14)
|
|
(level-group-method-15 () none) ;; 15 ;; (debug-draw-actors (_type_ symbol) none 15)
|
|
(level-group-method-16 () none) ;; 16 ;; (assign-draw-indices (_type_) none 16)
|
|
(level-group-method-17 () none) ;; 17 ;; (actors-update (_type_) none 17)
|
|
(level-group-method-18 () none) ;; 18 ;; (update-nav-meshes-method (_type_) none 18)
|
|
(level-group-method-19 () none) ;; 19 ;; (level-update (_type_) none 19)
|
|
(level-group-method-20 () none) ;; 20 ;; (level-get-target-inside (_type_) level 20)
|
|
(level-group-method-21 () none) ;; 21 ;; (alloc-levels-if-needed (_type_ symbol) none 21)
|
|
(level-group-method-22 () none) ;; 22 ;; (load-commands-set! (_type_ pair) none 22)
|
|
(level-group-method-23 () none) ;; 23 ;; (art-group-get-by-name (_type_ string (pointer uint32)) art-group 23)
|
|
(level-group-method-24 () none) ;; 24 ;; (alt-load-command-get-index (_type_ symbol int) pair 24)
|
|
(level-group-method-25 () none) ;; 25 ;; (update-vis-volumes (_type_) none 25)
|
|
(level-group-method-26 () none) ;; 26 ;; (update-vis-volumes-from-nav-mesh (_type_) none 26)
|
|
(level-group-method-27 () none) ;; 27 ;; (print-volume-sizes (_type_) none 27)
|
|
(level-group-method-28 () none) ;; 28 ;; (level-status (_type_ symbol) symbol 28)
|
|
(level-group-method-29 () none) ;; 29 ;; (load-in-progress? (_type_) symbol 29)
|
|
(level-group-method-30 () none) ;; 30 ;; (level-get-most-disposable (_type_) level 30)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *level* level-group) ;; level-group
|
|
;; (define-extern *draw-index* object) ;; int
|
|
;; (define-extern *level-index* object) ;; int
|
|
;; (define-extern *city-mode* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-dummy-art ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *gun-kg-robo-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-kg-bomb-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-kg-b-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-kg-c-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-kg-big-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-kg-bonus-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-rc-three-eyes-bonus-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-rc-two-eyes-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-rc-three-eyes-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-rc-one-eye-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-rc-four-eyes-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-rachet-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-clank-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *gun-cit-a-exploder-params* joint-exploder-static-params) ;; joint-exploder-static-params
|
|
;; (define-extern *gun-cit-b-exploder-params* joint-exploder-static-params) ;; joint-exploder-static-params
|
|
;; (define-extern *gun-cit-c-exploder-params* joint-exploder-static-params) ;; joint-exploder-static-params
|
|
;; (define-extern *gun-cit-d-exploder-params* joint-exploder-static-params) ;; joint-exploder-static-params
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lightning-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype lightning-spec (basic)
|
|
((name string :offset-assert 4) ;; guessed by decompiler
|
|
(flags uint16 :offset-assert 8) ;; lightning-spec-flags
|
|
(rand-func uint8 :offset-assert 10)
|
|
(adjust-distance uint8 :offset-assert 11)
|
|
(start-color rgba :offset-assert 12) ;; guessed by decompiler
|
|
(end-color rgba :offset-assert 16) ;; guessed by decompiler
|
|
(fade-to-color rgba :offset-assert 20) ;; guessed by decompiler
|
|
(fade-start-factor float :offset-assert 24)
|
|
(fade-time float :offset-assert 28)
|
|
(texture texture-id :offset-assert 32) ;; guessed by decompiler
|
|
(reduction float :offset-assert 36)
|
|
(num-points int32 :offset-assert 40)
|
|
(box-size float :offset-assert 44)
|
|
(merge-factor float :offset-assert 48)
|
|
(merge-count int32 :offset-assert 52)
|
|
(radius float :offset-assert 56)
|
|
(duration float :offset-assert 60)
|
|
(duration-rand float :offset-assert 64)
|
|
(sound basic :offset-assert 68)
|
|
(delay float :offset-assert 72)
|
|
(delay-rand float :offset-assert 76)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-state (structure)
|
|
((mode uint8 :offset-assert 0) ;; lightning-mode
|
|
(counter float :offset-assert 4)
|
|
(points-to-draw int32 :offset-assert 8)
|
|
(box-size float :offset-assert 12)
|
|
(gcf-control gcf-control :inline :offset-assert 16)
|
|
(line vector-array :offset-assert 128) ;; guessed by decompiler
|
|
(meet vector-array :offset-assert 132) ;; guessed by decompiler
|
|
(path vector-array :offset-assert 136) ;; guessed by decompiler
|
|
(start-color rgba :offset-assert 140) ;; guessed by decompiler
|
|
(end-color rgba :offset-assert 144) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x94
|
|
:flag-assert #x900000094
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-control (basic)
|
|
((spec lightning-spec :offset-assert 4) ;; guessed by decompiler
|
|
(process (pointer process) :offset-assert 8) ;; guessed by decompiler
|
|
(state lightning-state :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #xa4
|
|
:flag-assert #xe000000a4
|
|
(:methods
|
|
;; (new (symbol type lightning-spec process float) _type_ 0)
|
|
(lightning-control-method-9 () none) ;; 9 ;; (change-mode (_type_ lightning-mode) lightning-mode 9)
|
|
(lightning-control-method-10 () none) ;; 10 ;; (get-mode (_type_) lightning-mode 10)
|
|
(lightning-control-method-11 () none) ;; 11 ;; (set-point! (_type_ int vector) none 11)
|
|
(lightning-control-method-12 () none) ;; 12 ;; (set-first-meet-point (_type_ vector) none 12)
|
|
(lightning-control-method-13 () none) ;; 13 ;; (set-last-meet-point (_type_ vector) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-probe-vars (basic)
|
|
((src-joint-index uint32 :offset-assert 4)
|
|
(next-spawn-time uint64 :offset-assert 8) ;; time-frame
|
|
(last-valid-time uint64 :offset-assert 16) ;; time-frame
|
|
(point vector 2 :offset-assert 32) ;; guessed by decompiler
|
|
(start-pos vector :inline :offset-assert 32)
|
|
(end-pos vector :inline :offset-assert 48)
|
|
(probe-dirs (inline-array vector) :offset-assert 64) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
;; (define-extern lookup-lightning-spec-by-name function) ;; (function string lightning-spec)
|
|
;; (define-extern *lightning-probe-vars* lightning-probe-vars) ;; lightning-probe-vars
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desresc-path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype desert-transport-node (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(is-stop? basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *desresc-transport-path-0* array)
|
|
;; (define-extern *desresc-transport-path-1* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; math-camera-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vis-gif-tag (structure)
|
|
((fog0 uint32 :offset-assert 0)
|
|
(strip uint32 :offset-assert 4)
|
|
(regs uint32 :offset-assert 8)
|
|
(fan uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cull-info (structure)
|
|
((x-fact float :offset-assert 0)
|
|
(y-fact float :offset-assert 4)
|
|
(z-fact float :offset-assert 8)
|
|
(cam-radius float :offset-assert 12)
|
|
(cam-x float :offset-assert 16)
|
|
(cam-y float :offset-assert 20)
|
|
(xz-dir-ax float :offset-assert 24)
|
|
(xz-dir-az float :offset-assert 28)
|
|
(xz-dir-bx float :offset-assert 32)
|
|
(xz-dir-bz float :offset-assert 36)
|
|
(xz-cross-ab float :offset-assert 40)
|
|
(yz-dir-ay float :offset-assert 44)
|
|
(yz-dir-az float :offset-assert 48)
|
|
(yz-dir-by float :offset-assert 52)
|
|
(yz-dir-bz float :offset-assert 56)
|
|
(yz-cross-ab float :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype math-camera (basic)
|
|
((d meters :offset-assert 4)
|
|
(f meters :offset-assert 8)
|
|
(fov deg :offset-assert 12) ;; degrees
|
|
(x-ratio float :offset-assert 16)
|
|
(y-ratio float :offset-assert 20)
|
|
(x-pix float :offset-assert 24)
|
|
(x-clip float :offset-assert 28)
|
|
(x-clip-ratio-in float :offset-assert 32)
|
|
(x-clip-ratio-over float :offset-assert 36)
|
|
(y-pix float :offset-assert 40)
|
|
(y-clip float :offset-assert 44)
|
|
(y-clip-ratio-in float :offset-assert 48)
|
|
(y-clip-ratio-over float :offset-assert 52)
|
|
(cull-info cull-info :inline :offset-assert 56)
|
|
(fog-start meters :offset-assert 120)
|
|
(fog-end meters :offset-assert 124)
|
|
(fog-max float :offset-assert 128)
|
|
(fog-min float :offset-assert 132)
|
|
(reset int32 :offset-assert 136)
|
|
(smooth-step float :offset-assert 140)
|
|
(smooth-t float :offset-assert 144)
|
|
(perspective matrix :inline :offset-assert 160)
|
|
(isometric matrix :inline :offset-assert 224)
|
|
(sprite-2d matrix :inline :offset-assert 288)
|
|
(sprite-2d-hvdf vector :inline :offset-assert 352)
|
|
(camera-rot matrix :inline :offset-assert 368)
|
|
(inv-camera-rot matrix :inline :offset-assert 432)
|
|
(inv-camera-rot-smooth matrix :inline :offset-assert 496)
|
|
(inv-camera-rot-smooth-from quaternion :inline :offset-assert 560)
|
|
(camera-temp matrix :inline :offset-assert 576)
|
|
(prev-camera-temp matrix :inline :offset-assert 640)
|
|
(prev-inv-camera-rot matrix :inline :offset-assert 704)
|
|
(prev-trans vector :inline :offset-assert 768)
|
|
(hmge-scale vector :inline :offset-assert 784)
|
|
(inv-hmge-scale vector :inline :offset-assert 800)
|
|
(hvdf-off vector :inline :offset-assert 816)
|
|
(guard vector :inline :offset-assert 832)
|
|
(vis-gifs vis-gif-tag 4 :offset-assert 848) ;; guessed by decompiler
|
|
(giftex uint128 :offset-assert 848)
|
|
(gifgr uint128 :offset-assert 864)
|
|
(giftex-trans uint128 :offset-assert 880)
|
|
(gifgr-trans uint128 :offset-assert 896)
|
|
(pfog0 float :offset-assert 912)
|
|
(pfog1 float :offset-assert 916)
|
|
(trans vector :inline :offset-assert 928)
|
|
(plane plane 4 :offset-assert 944) ;; guessed by decompiler
|
|
(guard-plane plane 4 :offset-assert 1008) ;; guessed by decompiler
|
|
(shrub-mat matrix :inline :offset-assert 1072)
|
|
(quat-other quaternion :inline :offset-assert 1136)
|
|
(trans-other vector :inline :offset-assert 1152)
|
|
(shrub-mat-other matrix :inline :offset-assert 1168)
|
|
(camera-temp-other matrix :inline :offset-assert 1232)
|
|
(camera-rot-other matrix :inline :offset-assert 1296)
|
|
(camera-rot-other-sky matrix :inline :offset-assert 1360)
|
|
(camera-rot-other-sprite matrix :inline :offset-assert 1424)
|
|
(inv-camera-rot-other matrix :inline :offset-assert 1488)
|
|
(plane-other plane 4 :offset-assert 1552) ;; guessed by decompiler
|
|
(guard-plane-other plane 4 :offset-assert 1616) ;; guessed by decompiler
|
|
(mirror-trans vector :inline :offset-assert 1680)
|
|
(mirror-normal vector :inline :offset-assert 1696)
|
|
(fov-correction-factor float :offset-assert 1712)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6b4
|
|
:flag-assert #x9000006b4
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prim-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype prim-vertex (structure)
|
|
((stq vector :inline :offset-assert 0)
|
|
(nokick uint32 :offset-assert 8)
|
|
(col uint32 :offset-assert 12)
|
|
(pos vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prim-base (basic)
|
|
()
|
|
:method-count-assert 10
|
|
:size-assert #x4
|
|
:flag-assert #xa00000004
|
|
(:methods
|
|
(prim-base-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prim-strip (prim-base)
|
|
((flags uint32 :offset-assert 4)
|
|
(tex-name basic :offset-assert 8)
|
|
(num-verts uint16 :offset-assert 12)
|
|
(allocated-num-verts uint16 :offset-assert 14)
|
|
(tex-id uint32 :offset-assert 16)
|
|
(adnops UNKNOWN 2 :offset-assert 32)
|
|
(data0 uint64 :offset-assert 32)
|
|
(reg0 uint64 :offset-assert 40)
|
|
(data1 uint64 :offset-assert 48)
|
|
(reg1 uint64 :offset-assert 56)
|
|
(clamp uint64 :offset-assert 64)
|
|
(alpha uint64 :offset-assert 72)
|
|
(bucket int32 :offset-assert 80)
|
|
(sink uint32 :offset-assert 84)
|
|
(level basic :offset-assert 88)
|
|
(texture-index uint32 :offset-assert 92)
|
|
(data UNKNOWN :dynamic :offset-assert 96)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x60
|
|
:flag-assert #xb00000060
|
|
(:methods
|
|
(prim-strip-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prim-sink (structure)
|
|
((vertex-count uint8 :offset-assert 0)
|
|
(control-count uint8 :offset-assert 1)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prim-work (structure)
|
|
((vertex-tmpl UNKNOWN 3 :offset-assert 0)
|
|
(control-tmpl UNKNOWN 2 :offset-assert 48)
|
|
(giftag generic-gif-tag :inline :offset-assert 80)
|
|
(call-scissor dma-packet :inline :offset-assert 96)
|
|
(call-noclip dma-packet :inline :offset-assert 112)
|
|
(shader adgif-shader :inline :offset-assert 128)
|
|
(mask vector4w :inline :offset-assert 208)
|
|
(in-verts int32 :offset-assert 224)
|
|
(num-verts int32 :offset-assert 228)
|
|
(vert-ptr prim-vertex :offset-assert 232)
|
|
(sinks UNKNOWN 68 :offset-assert 236)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x52c
|
|
:flag-assert #xa0000052c
|
|
(:methods
|
|
(prim-work-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lightning ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype lightning-globals (structure)
|
|
((gcf-buf uint16 :offset-assert 0)
|
|
(vtx-buf uint16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *lightning-spec-id-table* object) ;; (array lightning-spec)
|
|
;; (define-extern *lightning-gcf* object) ;; gcf-control
|
|
;; (define-extern lightning-fractal-gen function) ;; (function (inline-array vector) int int float lightning-spec none)
|
|
;; (define-extern lightning-uniform-gen function) ;; (function (inline-array vector) int int float lightning-spec none)
|
|
;; (define-extern lightning-trail-uniform-gen function) ;; (function (inline-array vector) (inline-array vector) float int symbol)
|
|
;; (define-extern lightning-trail-fractal-gen function) ;; (function (inline-array vector) (inline-array vector) int int float lightning-spec none)
|
|
;; (define-extern gs-packed-rgba-lerp! function) ;; (function gs-packed-rgba rgba rgba float gs-packed-rgba)
|
|
;; (define-extern lightning-fade function) ;; (function lightning-control int :behavior process)
|
|
;; (define-extern lightning-update function) ;; (function lightning-control symbol)
|
|
;; (define-extern lightning-draw function) ;; (function dma-buffer lightning-control lightning-globals symbol)
|
|
;; (define-extern lightning-start function) ;; (function float float (pointer process))
|
|
;; (define-extern *lightning-globals* object) ;; lightning-globals
|
|
;; (define-extern *lightning* object) ;; symbol
|
|
;; (define-extern lightning-draw-all function) ;; (function none)
|
|
;; (define-extern unlink-lightning-spec-by-heap function) ;; (function kheap none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; math-camera ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fog-corrector (structure)
|
|
((fog-end float :offset-assert 0)
|
|
(fog-start float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern fog-corrector-setup function) ;; (function fog-corrector math-camera none)
|
|
;; (define-extern *math-camera-fog-correction* object) ;; fog-corrector
|
|
;; (define-extern update-math-camera function) ;; (function math-camera symbol symbol float math-camera)
|
|
;; (define-extern *math-camera* object) ;; math-camera
|
|
;; (define-extern math-cam-start-smoothing function) ;; (function float float quaternion)
|
|
;; (define-extern move-target-from-pad function) ;; (function transform int transform)
|
|
;; (define-extern transform-point-vector! function) ;; (function vector vector symbol)
|
|
;; (define-extern transform-point-qword! function) ;; (function vector4w vector symbol)
|
|
;; (define-extern transform-point-vector-scale! function) ;; (function vector vector float)
|
|
;; (define-extern reverse-transform-point! function) ;; (function vector vector vector vector none)
|
|
;; (define-extern init-for-transform function) ;; (function matrix none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prim ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *prim-work* object)
|
|
;; (define-extern prim-engine-execute function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; waspal-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype waspala-states (structure)
|
|
((flame0 flames-state :inline :offset-assert 0)
|
|
(flame1 flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
;; (define-extern calc-waspala-lights function)
|
|
;; (define-extern update-mood-waspala function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; font-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype char-verts (structure)
|
|
((pos vector 4 :offset-assert 0) ;; guessed by decompiler
|
|
(color vector 4 :offset-assert 64) ;; guessed by decompiler
|
|
(tex-st vector 4 :offset-assert 128) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc0
|
|
:flag-assert #x9000000c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype char-color (structure)
|
|
((color rgba 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype font-context (basic)
|
|
((origin vector :inline :offset-assert 16)
|
|
(strip-gif vector :inline :offset-assert 32)
|
|
(width float :offset-assert 48)
|
|
(height float :offset-assert 52)
|
|
(projection float :offset-assert 56)
|
|
(scale float :offset-assert 60)
|
|
(color font-color :offset-assert 64) ;; guessed by decompiler
|
|
(flags font-flags :offset-assert 68) ;; guessed by decompiler
|
|
(mat matrix :offset-assert 72)
|
|
(start-line uint32 :offset-assert 76)
|
|
(alpha float :offset-assert 80)
|
|
(max-x float :offset-assert 84)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x58
|
|
:flag-assert #x1500000058
|
|
(:methods
|
|
;; (new (symbol type matrix int int float font-color font-flags) _type_ 0)
|
|
(font-context-method-9 () none) ;; 9 ;; (set-mat! (font-context matrix) font-context 9)
|
|
(font-context-method-10 () none) ;; 10 ;; (set-origin! (font-context int int) font-context 10)
|
|
(font-context-method-11 () none) ;; 11 ;; (set-depth! (font-context int) font-context 11)
|
|
(font-context-method-12 () none) ;; 12 ;; (set-w! (font-context float) font-context 12)
|
|
(font-context-method-13 () none) ;; 13 ;; (set-width! (font-context int) font-context 13)
|
|
(font-context-method-14 () none) ;; 14 ;; (set-height! (font-context int) font-context 14)
|
|
(font-context-method-15 () none) ;; 15 ;; (set-projection! (font-context float) font-context 15)
|
|
(font-context-method-16 () none) ;; 16 ;; (set-color! (font-context font-color) font-context 16)
|
|
(font-context-method-17 () none) ;; 17 ;; (set-flags! (font-context font-flags) font-context 17)
|
|
(font-context-method-18 () none) ;; 18 ;; (set-start-line! (font-context uint) font-context 18)
|
|
(font-context-method-19 () none) ;; 19 ;; (set-scale! (font-context float) font-context 19)
|
|
(font-context-method-20 () none) ;; 20 ;; (set-alpha! (font-context float) font-context 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype font-work (structure)
|
|
((font-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(char-tmpl dma-gif-packet :inline :offset-assert 32)
|
|
(tex1-tmpl uint64 2 :offset-assert 64) ;; guessed by decompiler
|
|
(small-font-0-tmpl uint64 2 :offset-assert 80) ;; guessed by decompiler
|
|
(small-font-1-tmpl uint64 2 :offset-assert 96) ;; guessed by decompiler
|
|
(small-font-2-tmpl uint64 2 :offset-assert 112) ;; guessed by decompiler
|
|
(small-font-3-tmpl uint64 2 :offset-assert 128) ;; guessed by decompiler
|
|
(large-font-0-tmpl uint64 2 :offset-assert 144) ;; guessed by decompiler
|
|
(large-font-1-tmpl uint64 2 :offset-assert 160) ;; guessed by decompiler
|
|
(large-font-2-tmpl uint64 2 :offset-assert 176) ;; guessed by decompiler
|
|
(large-font-3-tmpl uint64 2 :offset-assert 192) ;; guessed by decompiler
|
|
(size1-small vector :inline :offset-assert 208)
|
|
(size2-small vector :inline :offset-assert 224)
|
|
(size3-small vector :inline :offset-assert 240)
|
|
(size1-large vector :inline :offset-assert 256)
|
|
(size2-large-0 vector :inline :offset-assert 272)
|
|
(size2-large-1 vector :inline :offset-assert 288)
|
|
(size2-large-2 vector :inline :offset-assert 304)
|
|
(size2-large-3 vector :inline :offset-assert 320)
|
|
(size3-large vector :inline :offset-assert 336)
|
|
(size2-0 vector :inline :offset-assert 352)
|
|
(size2-1 vector :inline :offset-assert 368)
|
|
(size2-2 vector :inline :offset-assert 384)
|
|
(size2-3 vector :inline :offset-assert 400)
|
|
(size-st1 vector :inline :offset-assert 416)
|
|
(size-st2 vector :inline :offset-assert 432)
|
|
(size-st3 vector :inline :offset-assert 448)
|
|
(save vector :inline :offset-assert 464)
|
|
(save-color vector 4 :offset-assert 480) ;; guessed by decompiler
|
|
(character-save-color UNKNOWN 4 :offset-assert 544)
|
|
(current-verts char-verts :inline :offset-assert 608)
|
|
(src-verts char-verts :inline :offset-assert 800)
|
|
(dest-verts char-verts :inline :offset-assert 992)
|
|
(justify vector 64 :offset-assert 1184) ;; guessed by decompiler
|
|
(color-shadow vector4w :inline :offset-assert 2208)
|
|
(color-table char-color 45 :offset-assert 2224) ;; guessed by decompiler
|
|
(current-font-0-tmpl uint64 2 :offset-assert 2944) ;; guessed by decompiler
|
|
(current-font-1-tmpl uint64 2 :offset-assert 2960) ;; guessed by decompiler
|
|
(current-font-2-tmpl uint64 2 :offset-assert 2976) ;; guessed by decompiler
|
|
(current-font-3-tmpl uint64 2 :offset-assert 2992) ;; guessed by decompiler
|
|
(last-color font-color :offset-assert 3008) ;; guessed by decompiler
|
|
(save-last-color font-color :offset-assert 3012) ;; guessed by decompiler
|
|
(character-save-last-color uint32 :offset-assert 3016)
|
|
(buf basic :offset-assert 3020)
|
|
(str-ptr uint32 :offset-assert 3024)
|
|
(flags font-flags :offset-assert 3028) ;; guessed by decompiler
|
|
(reg-save uint32 5 :offset-assert 3032) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xbec
|
|
:flag-assert #xa00000bec
|
|
(:methods
|
|
(font-work-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *font-default-matrix* object) ;; matrix
|
|
;; (define-extern *font-work* object) ;; font-work
|
|
;; (define-extern font-set-tex0 function) ;; (function (pointer gs-tex0) texture int int int none)
|
|
;; (define-extern set-font-color function) ;; (function font-color int rgba rgba rgba int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; time-of-day-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype palette-fade-control (structure)
|
|
((trans vector :inline :offset-assert 0)
|
|
(fade float :offset-assert 16)
|
|
(actor-dist float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype palette-fade-controls (basic)
|
|
((control palette-fade-control 8 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x110
|
|
:flag-assert #xb00000110
|
|
(:methods
|
|
(palette-fade-controls-method-9 () none) ;; 9 ;; (reset! (_type_) none 9)
|
|
(palette-fade-controls-method-10 () none) ;; 10 ;; (set-fade! (_type_ int float float vector) object 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype time-of-day-proc (process)
|
|
((hours int32 :offset-assert 128)
|
|
(minutes int32 :offset-assert 132)
|
|
(seconds int32 :offset-assert 136)
|
|
(old-frame uint64 :offset-assert 144)
|
|
(current-frame uint64 :offset-assert 152)
|
|
(frames uint64 :offset-assert 160)
|
|
(time-of-day float :offset-assert 168)
|
|
(old-frame-save uint64 :offset-assert 176)
|
|
(current-frame-save uint64 :offset-assert 184)
|
|
(frames-save uint64 :offset-assert 192)
|
|
(time-of-day-save float :offset-assert 200)
|
|
(time-ratio float :offset-assert 204)
|
|
(dest-time-ratio float :offset-assert 208)
|
|
(dest-time-delta float :offset-assert 212)
|
|
(sun-count int32 :offset-assert 216)
|
|
(sun sparticle-launch-control :offset-assert 220) ;; guessed by decompiler
|
|
(green-sun-count int32 :offset-assert 224)
|
|
(green-sun sparticle-launch-control :offset-assert 228) ;; guessed by decompiler
|
|
(moon-count int32 :offset-assert 232)
|
|
(moon sparticle-launch-control :offset-assert 236) ;; guessed by decompiler
|
|
(day-star-count int32 :offset-assert 240)
|
|
(day-star basic :offset-assert 244)
|
|
(day-star-enable basic :offset-assert 248)
|
|
(start-timer int32 :offset-assert 252)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x100
|
|
:flag-assert #xe00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype time-of-day-palette (basic)
|
|
((width int32 :offset-assert 4)
|
|
(height int32 :offset-assert 8)
|
|
(pad int32 :offset-assert 12)
|
|
(data int32 1 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype time-of-day-context (basic)
|
|
((interp float 10 :offset-assert 4) ;; guessed by decompiler
|
|
(current-fog mood-fog :inline :offset-assert 48)
|
|
(current-sky-color vector :inline :offset-assert 96)
|
|
(current-env-color vector :inline :offset-assert 112)
|
|
(current-prt-color vector :inline :offset-assert 128)
|
|
(current-shadow-color vector :inline :offset-assert 144)
|
|
(light-group light-group 8 :offset-assert 160) ;; guessed by decompiler
|
|
(current-clouds mood-clouds :inline :offset-assert 1696)
|
|
(times vector 8 :offset-assert 1712) ;; guessed by decompiler
|
|
(title-light-group light-group :inline :offset-assert 1840)
|
|
(rim-light-group light-group :inline :offset-assert 2032)
|
|
(rim-light-group2 light-group :inline :offset-assert 2224)
|
|
(rim-light-group3 light-group :inline :offset-assert 2416)
|
|
(filter vector :inline :offset-assert 2608)
|
|
(filter-color vector :inline :offset-assert 2624)
|
|
(time float :offset-assert 2640)
|
|
(target-interp float :offset-assert 2644)
|
|
(erase-color rgba :offset-assert 2648) ;; guessed by decompiler
|
|
(sky symbol :offset-assert 2652) ;; guessed by decompiler
|
|
(special-mood basic :offset-assert 2656)
|
|
(use-camera-other basic :offset-assert 2660)
|
|
(title-updated symbol :offset-assert 2664) ;; guessed by decompiler
|
|
(mode time-of-day-palette-id :offset-assert 2668) ;; guessed by decompiler
|
|
(overide-enable symbol :offset-assert 2672) ;; guessed by decompiler
|
|
(overide-palette time-of-day-palette-id :offset-assert 2676) ;; guessed by decompiler
|
|
(max-rain float :offset-assert 2680)
|
|
(fog-mult float :offset-assert 2684)
|
|
(exterior-level basic :offset-assert 2688)
|
|
(ocean-alpha float :offset-assert 2692)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa88
|
|
:flag-assert #x900000a88
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype time-of-day-dma (structure)
|
|
((outa uint32 256 :offset-assert 0) ;; guessed by decompiler
|
|
(outb uint32 256 :offset-assert 1024) ;; guessed by decompiler
|
|
(banka uint32 256 :offset-assert 2048) ;; guessed by decompiler
|
|
(bankb uint32 256 :offset-assert 3072) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1000
|
|
:flag-assert #x900001000
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *palette-fade-controls* object) ;; palette-fade-controls
|
|
;; (define-extern *time-of-day-context* time-of-day-context) ;; time-of-day-context
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-mesh ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-find-clear-spot-work (structure)
|
|
((id-array UNKNOWN 16 :offset-assert 0)
|
|
(sphere-array UNKNOWN 16 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x110
|
|
:flag-assert #x900000110
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *debug-nav-control-output* object) ;; symbol
|
|
;; (define-extern *debug-nav-control* object) ;; symbol
|
|
;; (define-extern *debug-nav-mesh-output* object) ;; symbol
|
|
;; (define-extern *debug-nav-ray* object) ;; nav-ray
|
|
;; (define-extern *debug-ray-offset* object) ;; vector
|
|
;; (define-extern *debug-offset* object) ;; vector
|
|
;; (define-extern *nav-mesh-work* object) ;; nav-mesh-work
|
|
;; (define-extern *default-nav-mesh* nav-mesh) ;; nav-mesh
|
|
;; (define-extern nav-mesh-connect-from-ent function) ;; (function process-drawable symbol)
|
|
;; (define-extern connection-validate function) ;; (function connection none)
|
|
;; (define-extern connection-list-validate function) ;; (function (inline-array connection) symbol)
|
|
;; (define-extern nav-control-validate function) ;; (function process-drawable none)
|
|
;; (define-extern debug-validate-nav-poly function) ;; (function nav-mesh-link nav-poly none)
|
|
;; (define-extern vu-point-triangle-intersection? function) ;; (function vector vector vector vector symbol)
|
|
;; (define-extern poly-in-height-range? function) ;; (function nav-poly float float symbol)
|
|
;; (define-extern init-ray-local function) ;; (function nav-ray nav-poly vector vector none)
|
|
;; (define-extern init-ray-dir-local function) ;; (function nav-ray nav-poly vector vector float none)
|
|
;; (define-extern nav-ray-test function) ;; (function nav-mesh nav-poly vector vector meters)
|
|
;; (define-extern point-poly-distance-min function) ;; (function nav-mesh-work nav-poly float nav-poly float)
|
|
;; (define-extern nav-mesh-route-table-bit-index function) ;; (function nav-mesh uint int int)
|
|
;; (define-extern ray-ccw-line-segment-intersection? function) ;; (function vector vector vector vector symbol)
|
|
;; (define-extern ray-line-segment-intersection? function) ;; (function vector vector vector vector symbol)
|
|
;; (define-extern plane-height-at-xz-point function) ;; (function plane vector float)
|
|
;; (define-extern nav-normal-from-3-points function) ;; (function vector vector vector vector none)
|
|
;; (define-extern get-nav-mesh function) ;; (function actor-id nav-mesh)
|
|
;; (define-extern find-nearest-nav-mesh function) ;; (function vector float nav-mesh)
|
|
;; (define-extern point-to-poly-boundary function) ;; (function nav-poly vector vector float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; minimap ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype minimap-texture-name-array (structure)
|
|
((data string 35 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8c
|
|
:flag-assert #x90000008c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype minimap-corner-array (structure)
|
|
((data vector 35 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x230
|
|
:flag-assert #x900000230
|
|
)
|
|
|#
|
|
|
|
;; engine-minimap is already defined!
|
|
|
|
;; (define-extern *minimap-texture-name-array* object) ;; minimap-texture-name-array
|
|
;; (define-extern *minimap-corner-array* object) ;; minimap-corner-array
|
|
;; (define-extern *minimap* object) ;; minimap
|
|
;; (define-extern *minimap-class-list* object) ;; (inline-array minimap-class-node)
|
|
;; (define-extern lookup-minimap-texture-by-name function) ;; (function string string (pointer texture-page) texture)
|
|
;; (define-extern *minimap-table-entry-array* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; display ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern get-current-time function) ;; (function time-frame)
|
|
;; (define-extern get-integral-current-time function) ;; (function uint)
|
|
;; (define-extern get-real-current-time function)
|
|
;; (define-extern set-display function) ;; (function display display)
|
|
;; (define-extern allocate-dma-buffers function) ;; (function display display)
|
|
;; (define-extern *font-context* object) ;; font-context
|
|
;; (define-extern draw-sprite2d-xy function) ;; (function dma-buffer int int int int rgba none)
|
|
;; (define-extern draw-sprite2d-xy-absolute function) ;; (function dma-buffer int int int int rgba none)
|
|
;; (define-extern draw-quad2d function) ;; (function dma-buffer draw-context none)
|
|
;; (define-extern screen-gradient function) ;; (function dma-buffer rgba rgba rgba rgba none)
|
|
;; (define-extern vif1-handler-debug function) ;; (function int none)
|
|
;; (define-extern vif1-handler function) ;; (function none)
|
|
;; (define-extern vblank-handler function) ;; (function int)
|
|
;; (define-extern set-display-gs-state function) ;; (function dma-buffer int int int int int dma-buffer)
|
|
;; (define-extern set-display-gs-state-offset function) ;; (function dma-buffer int int int int int int int dma-buffer)
|
|
;; (define-extern reset-display-gs-state function) ;; (function display dma-buffer display)
|
|
;; (define-extern *vu0-dma-list* object) ;; dma-buffer
|
|
;; (define-extern *display* object) ;; display
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; spydroid-orig ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype spydroid-orig (nav-enemy)
|
|
((old-y-deg float :offset-assert 620)
|
|
(diff-angle float :offset-assert 624)
|
|
(flags uint64 :offset-assert 632)
|
|
(lightning UNKNOWN 4 :offset-assert 640)
|
|
(floor float :offset-assert 656)
|
|
(explode-part basic :offset-assert 660)
|
|
)
|
|
:method-count-assert 192
|
|
:size-assert #x298
|
|
:flag-assert #xc002200298
|
|
(:state-methods
|
|
explode ;; 191
|
|
die-falling ;; 41
|
|
attack ;; 190
|
|
hostile ;; 38
|
|
notice ;; 35
|
|
circling ;; 157
|
|
stare ;; 37
|
|
pacing ;; 156
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *spydroid-orig-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *fact-info-spydroid-orig-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *spydroid-orig-nav-enemy-info* nav-enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; connect ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype connectable (structure)
|
|
((next0 connectable :offset-assert 0)
|
|
(prev0 connectable :offset-assert 4)
|
|
(next1 connectable :offset-assert 8)
|
|
(prev1 connectable :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype connection (connectable)
|
|
((param0 basic :offset-assert 16)
|
|
(param1 basic :offset-assert 20)
|
|
(param2 int32 :offset-assert 24) ;; guessed by decompiler
|
|
(param3 int32 :offset-assert 28) ;; guessed by decompiler
|
|
(quad uint128 2 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x20
|
|
:flag-assert #xe00000020
|
|
;; field param1 uses ~A with a signed load. field param2 uses ~A with a signed load. field param3 uses ~A with a signed load.
|
|
(:methods
|
|
(connection-method-9 () none) ;; 9 ;; (get-engine (connection) engine 9)
|
|
(connection-method-10 () none) ;; 10 ;; (get-process (connection) process 10)
|
|
(connection-method-11 () none) ;; 11 ;; (belongs-to-engine? (connection engine) symbol 11)
|
|
(connection-method-12 () none) ;; 12 ;; (belongs-to-process? (connection process) symbol 12)
|
|
(connection-method-13 () none) ;; 13 ;; (move-to-dead (connection) connection 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype engine (basic)
|
|
((name symbol :offset-assert 4) ;; guessed by decompiler
|
|
(engine-time uint64 :offset-assert 16) ;; time-frame
|
|
(allocated-length int16 :offset-assert 10)
|
|
(length int16 :offset-assert 8)
|
|
(element-type type :offset-assert 12) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(data connection :dynamic :offset-assert 96) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x60
|
|
:flag-assert #x1a00000060
|
|
(:methods
|
|
;; (new (symbol type symbol int type) _type_ 0)
|
|
(engine-method-9 () none) ;; 9 ;; (inspect-all-connections (engine) engine 9)
|
|
(engine-method-10 () none) ;; 10 ;; (apply-to-connections (engine (function connectable none)) int 10)
|
|
(engine-method-11 () none) ;; 11 ;; (apply-to-connections-reverse (engine (function connectable none)) int 11)
|
|
(engine-method-12 () none) ;; 12 ;; (execute-connections (engine object) int 12)
|
|
(engine-method-13 () none) ;; 13 ;; (execute-connections-and-move-to-dead (engine object) int 13)
|
|
(engine-method-14 () none) ;; 14 ;; (execute-connections-if-needed (engine object) int 14)
|
|
(engine-method-15 () none) ;; 15 ;; (add-connection (engine process object object object object) connection 15)
|
|
(engine-method-16 () none) ;; 16 ;; (remove-from-process (engine process) int 16)
|
|
(engine-method-17 () none) ;; 17 ;; (remove-matching (engine (function connection engine symbol)) int 17)
|
|
(engine-method-18 () none) ;; 18 ;; (remove-all (engine) int 18)
|
|
(engine-method-19 () none) ;; 19 ;; (remove-by-param0 (engine object) int 19)
|
|
(engine-method-20 () none) ;; 20 ;; (remove-by-param1 (engine int) int 20)
|
|
(engine-method-21 () none) ;; 21 ;; (remove-by-param2 (engine int) int 21)
|
|
(engine-method-22 () none) ;; 22 ;; (get-first-connectable (engine) connectable 22)
|
|
(engine-method-23 () none) ;; 23 ;; (get-last-connectable (engine) connectable 23)
|
|
(engine-method-24 () none) ;; 24 ;; (get-next-connectable (_type_ connectable) connectable 24)
|
|
(engine-method-25 () none) ;; 25 ;; (get-prev-connectable (_type_ connectable) connectable 25)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype connection-pers (structure)
|
|
((next connection-pers :offset-assert 0)
|
|
(key object :offset-assert 4) ;; guessed by decompiler
|
|
(update-time uint64 :offset-assert 8) ;; time-frame
|
|
(param object 4 :offset-assert 16) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(param-int32 int32 4 :offset-assert 16) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(param-int64 int64 2 :offset-assert 16) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(param-float float 4 :offset-assert 16) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(param-quat uint128 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
;; field key uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype engine-pers (basic)
|
|
((name symbol :offset-assert 4) ;; guessed by decompiler
|
|
(length int16 :offset-assert 8)
|
|
(allocated-length int16 :offset-assert 10)
|
|
(element-type type :offset-assert 12) ;; guessed by decompiler
|
|
(execute-time uint64 :offset-assert 16) ;; time-frame
|
|
(alive-list connection-pers :offset-assert 24)
|
|
(dead-list connection-pers :offset-assert 28)
|
|
(data connection-pers :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x20
|
|
:flag-assert #xf00000020
|
|
(:methods
|
|
;; (new (symbol type symbol int type) _type_ 0)
|
|
(engine-pers-method-9 () none) ;; 9 ;; (schedule-callback (_type_ object time-frame) connection-pers 9)
|
|
(engine-pers-method-10 () none) ;; 10 ;; (kill-callback (_type_ connection-pers) none 10)
|
|
(engine-pers-method-11 () none) ;; 11 ;; (kill-by-key (_type_ object) none 11)
|
|
(engine-pers-method-12 () none) ;; 12 ;; (kill-matching (_type_ (function engine-pers connection-pers object object symbol) object object) none 12)
|
|
(engine-pers-method-13 () none) ;; 13 ;; (update-callback (_type_) none 13)
|
|
(engine-pers-method-14 () none) ;; 14 ;; (run-pending-updates! (_type_ time-frame) none 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern connection-process-apply function) ;; (function process (function object none) symbol)
|
|
;; (define-extern process-disconnect function) ;; (function process int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rope-prim-system ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *rope-prim-alpha-blend* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; trail-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype trail-node (structure)
|
|
((next-id int16 :offset-assert 0)
|
|
(prev-id int16 :offset-assert 2)
|
|
(parent-id int16 :offset-assert 4)
|
|
(x int16 :offset-assert 6)
|
|
(y int16 :offset-assert 8)
|
|
(z int16 :offset-assert 10)
|
|
(first-conn uint16 :offset-assert 12)
|
|
(cost-from-start uint16 :offset-assert 14)
|
|
(cost-to-goal uint16 :offset-assert 16)
|
|
(flags uint8 :offset-assert 18) ;; trail-node-flag
|
|
(conn-count uint8 :offset-assert 19)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x14
|
|
:flag-assert #xc00000014
|
|
(:methods
|
|
(trail-node-method-9 () none) ;; 9 ;; (get-dist-score (_type_ vector) uint 9)
|
|
(trail-node-method-10 () none) ;; 10 ;; (debug-draw (_type_ int) none 10)
|
|
(trail-node-method-11 () none) ;; 11 ;; (get-position (_type_ vector) vector 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-visgroup (structure)
|
|
((first-node uint16 :offset-assert 0)
|
|
(node-count uint8 :offset-assert 2)
|
|
(pad uint8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-blocker (structure)
|
|
((plane plane :inline :offset-assert 0)
|
|
(center vector :inline :offset-assert 16)
|
|
(radius-squared float :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-conn (structure)
|
|
((head-id uint16 :offset-assert 0)
|
|
(tail-id uint16 :offset-assert 2)
|
|
(flags uint8 :offset-assert 4) ;; conn-flag
|
|
(visgroup-id uint8 :offset-assert 5)
|
|
(cost uint16 :offset-assert 6)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x8
|
|
:flag-assert #xa00000008
|
|
(:methods
|
|
(trail-conn-method-9 () none) ;; 9 ;; (debug-draw (_type_ trail-graph int) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-conn-hash-cell (structure)
|
|
((first-conn uint16 :offset-assert 0)
|
|
(conn-count uint8 :offset-assert 2)
|
|
(pov-count uint8 :offset-assert 3)
|
|
(first-pov uint16 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-conn-search (structure)
|
|
((best-conn-id int32 :offset-assert 0)
|
|
(best-dist float :offset-assert 4)
|
|
(src-pos vector :offset-assert 8)
|
|
(conn-pos vector :offset-assert 12)
|
|
(debug-cells-searched int32 :offset-assert 16)
|
|
(debug-conns-searched int32 :offset-assert 20)
|
|
(bounds bounding-box4w :inline :offset-assert 32)
|
|
(cell-quads qword 2 :offset-assert 64) ;; guessed by decompiler
|
|
(conn-quads qword 7 :offset-assert 96) ;; guessed by decompiler
|
|
(cell-bits vector16ub 2 :offset-assert 64) ;; guessed by decompiler
|
|
(conn-bits UNKNOWN 2 :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xd0
|
|
:flag-assert #x9000000d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-conn-hash (basic)
|
|
((cell-width meters :offset-assert 4)
|
|
(origin vector :inline :offset-assert 16)
|
|
(cell (inline-array trail-conn-hash-cell) :offset-assert 32) ;; guessed by decompiler
|
|
(conn-ids (pointer uint16) :offset-assert 36) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-cached-search-info (structure)
|
|
((goal-conn-id int16 :offset-assert 0)
|
|
(orig-goal-pos vector :inline :offset-assert 16)
|
|
(conn-goal-pos vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-cached-start-pov (structure)
|
|
((last-updated uint64 :offset-assert 0)
|
|
(pov-can-see-start uint64 :offset-assert 8)
|
|
(next-node-id int32 :offset-assert 16)
|
|
(start-pos vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trail-graph (basic)
|
|
((mode uint8 :offset-assert 4)
|
|
(search-id uint32 :offset-assert 8)
|
|
(open-head-id int16 :offset-assert 12)
|
|
(goal-conn-id int16 :offset-assert 14)
|
|
(goal-node-id int16 :offset-assert 16)
|
|
(over-under-thresh float :offset-assert 20)
|
|
(over-under-above-too-low float :offset-assert 24)
|
|
(over-under-below-too-high float :offset-assert 28)
|
|
(pov-node-count uint16 :offset-assert 32)
|
|
(node-count uint16 :offset-assert 34)
|
|
(conn-count uint16 :offset-assert 36)
|
|
(blocker-count uint16 :offset-assert 38)
|
|
(conn-mask uint8 :offset-assert 40)
|
|
(node (inline-array trail-node) :offset-assert 44) ;; guessed by decompiler
|
|
(conn (inline-array trail-conn) :offset-assert 48) ;; guessed by decompiler
|
|
(blocker uint32 :offset-assert 52)
|
|
(conn-ids (pointer uint16) :offset-assert 56) ;; guessed by decompiler
|
|
(visgroup (inline-array trail-conn-hash-cell) :offset-assert 60) ;; guessed by decompiler
|
|
(visnode-ids (pointer uint16) :offset-assert 64) ;; guessed by decompiler
|
|
(conn-hash trail-conn-hash :offset-assert 68) ;; guessed by decompiler
|
|
(cell-pov-bit-arrays uint32 :offset-assert 72)
|
|
(pov-can-see-goal uint64 :offset-assert 80)
|
|
(cached-start-pov trail-cached-start-pov :inline :offset-assert 96)
|
|
(orig-start-pos vector :inline :offset-assert 144)
|
|
(orig-goal-pos vector :inline :offset-assert 160)
|
|
(conn-start-pos vector :inline :offset-assert 176)
|
|
(conn-goal-pos vector :inline :offset-assert 192)
|
|
(open-quads qword 6 :offset-assert 208) ;; guessed by decompiler
|
|
(closed-quads qword 6 :offset-assert 304) ;; guessed by decompiler
|
|
(open-bits UNKNOWN 2 :offset-assert 208)
|
|
(closed-bits UNKNOWN 2 :offset-assert 304)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x190
|
|
:flag-assert #x2200000190
|
|
(:methods
|
|
(trail-graph-method-9 () none) ;; 9 ;; (trail-graph-method-9 (_type_ int) none 9)
|
|
(trail-graph-method-10 () none) ;; 10 ;; (trail-graph-method-10 (_type_ int) none 10)
|
|
(trail-graph-method-11 () none) ;; 11 ;; (trail-graph-method-11 (_type_ int int) trail-node 11)
|
|
(trail-graph-method-12 () none) ;; 12 ;; (debug-draw (_type_) none 12)
|
|
(trail-graph-method-13 () none) ;; 13 ;; (debug-draw-cell (_type_ int) none 13)
|
|
(trail-graph-method-14 () none) ;; 14 ;; (debug-draw-path (_type_ int (pointer uint16) vector vector rgba float) symbol 14)
|
|
(trail-graph-method-15 () none) ;; 15 ;; (do-path (_type_ vector vector) int 15)
|
|
(trail-graph-method-16 () none) ;; 16 ;; (trail-graph-method-16 () none 16)
|
|
(trail-graph-method-17 () none) ;; 17 ;; (get-node-location-by-id (_type_ uint vector) vector 17)
|
|
(trail-graph-method-18 () none) ;; 18 ;; (get-path-to-root (_type_ (pointer uint16) int (pointer int32) (pointer float)) int 18)
|
|
(trail-graph-method-19 () none) ;; 19 ;; (trail-graph-method-19 (_type_ int int) symbol 19)
|
|
(trail-graph-method-20 () none) ;; 20 ;; (try-initialize (_type_) symbol 20)
|
|
(trail-graph-method-21 () none) ;; 21 ;; (update-node-flags-for-conn (_type_ int trail-node-flag trail-node-flag) none 21)
|
|
(trail-graph-method-22 () none) ;; 22 ;; (trail-graph-method-22 (_type_ int) none 22)
|
|
(trail-graph-method-23 () none) ;; 23 ;; (reset-search-state (_type_) none 23)
|
|
(trail-graph-method-24 () none) ;; 24 ;; (get-next-to-explore (_type_) int 24)
|
|
(trail-graph-method-25 () none) ;; 25 ;; (trail-graph-method-25 (_type_ trail-conn-search int int) none 25)
|
|
(trail-graph-method-26 () none) ;; 26 ;; (do-search! (_type_ vector vector trail-cached-search-info) none 26)
|
|
(trail-graph-method-27 () none) ;; 27 ;; (do-some-work (_type_) int 27)
|
|
(trail-graph-method-28 () none) ;; 28 ;; (run-until-done-or-timeout (_type_ int) none 28)
|
|
(trail-graph-method-29 () none) ;; 29
|
|
(trail-graph-method-30 () none) ;; 30
|
|
(trail-graph-method-31 () none) ;; 31
|
|
(trail-graph-method-32 () none) ;; 32
|
|
(trail-graph-method-33 () none) ;; 33
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *trail-graph* object) ;; trail-graph
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mood-tables2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *overide-mood-color-table* object) ;; mood-color-table
|
|
;; (define-extern *overide-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern init-overide-table function) ;; (function mood-table none)
|
|
;; (define-extern *overide-table* mood-table) ;; mood-table
|
|
;; (define-extern print-mood-tables function) ;; (function none)
|
|
;; (define-extern desaturate-mood-colors function) ;; (function float float float none)
|
|
;; (define-extern desaturate-mood-fog function) ;; (function (pointer mood-fog-table) float float none)
|
|
;; (define-extern *debug-mood-color-table* object)
|
|
;; (define-extern *debug-mood-fog-table* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dp-bipedal-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dp-bipedal-grenade-shot (projectile-bounce)
|
|
((blast-radius float :offset-assert 548)
|
|
)
|
|
:method-count-assert 44
|
|
:size-assert #x228
|
|
:flag-assert #x2c01b00228
|
|
(:state-methods
|
|
impact ;; 22
|
|
dissipate ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spawn-dp-bipedal-grenade function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcanox-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *volcanox-warp-texture-anim-array* texture-anim-array)
|
|
;; (define-extern volcanox-warp-texture-anim-func function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hanga-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern hanga-login function)
|
|
;; (define-extern hanga-activate function)
|
|
;; (define-extern hanga-deactivate function)
|
|
;; (define-extern *hanga-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; minimap-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype minimap-table-entry (structure)
|
|
((corner vector :inline :offset-assert 0)
|
|
(level-name basic :offset-assert 16)
|
|
(tex-name basic :offset-assert 20)
|
|
(meters-per-texel float :offset-assert 24)
|
|
(pos-scale float :offset-assert 28)
|
|
(min-inv-scale float :offset-assert 32)
|
|
(max-inv-scale float :offset-assert 36)
|
|
(switch-immediate basic :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype minimap-class-node (structure)
|
|
((default-position vector :inline :offset-assert 0)
|
|
(flags minimap-flag :offset-assert 16)
|
|
(name basic :offset-assert 20)
|
|
(icon-xy vector2ub :inline :offset-assert 24)
|
|
(class uint16 :offset-assert 26) ;; minimap-class
|
|
(scale float :offset-assert 28)
|
|
(color rgba :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x24
|
|
:flag-assert #xa00000024
|
|
(:methods
|
|
(minimap-class-node-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype connection-minimap (connection-pers)
|
|
((next connection-minimap :offset-assert 0) ;; connection-pers
|
|
(handle uint64 :offset-assert 8) ;; handle
|
|
(position vector :offset-assert 16) ;; object
|
|
(alpha float :offset-assert 20)
|
|
(flags minimap-flag :offset-assert 24)
|
|
(class minimap-class-node :offset-assert 28)
|
|
(node uint16 :offset-assert 32)
|
|
(edge-ry int16 :offset-assert 34) ;; float
|
|
(last-world-pos vector :inline :offset-assert 48)
|
|
(last-relative-pos vector :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
;; field key uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype engine-minimap (engine-pers)
|
|
((alive-list connection-minimap :offset-assert 24)
|
|
(dead-list connection-minimap :offset-assert 28)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x20
|
|
:flag-assert #xf00000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype minimap-trail (structure)
|
|
((used-by connection-minimap :offset-assert 0)
|
|
(search-id uint32 :offset-assert 4)
|
|
(node-count int16 :offset-assert 8)
|
|
(goal-node-id int32 :offset-assert 12)
|
|
(node-path-dist float :offset-assert 16)
|
|
(last-updated uint64 :offset-assert 24)
|
|
(cached-info trail-cached-search-info :inline :offset-assert 32)
|
|
(node-id uint16 64 :offset-assert 80) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #xd0
|
|
:flag-assert #xb000000d0
|
|
(:methods
|
|
(minimap-trail-method-9 () none) ;; 9 ;; (get-distance-with-path (_type_ vector vector) float 9)
|
|
(minimap-trail-method-10 () none) ;; 10 ;; (reset (_type_) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype minimap-draw-work (structure)
|
|
((buf dma-buffer :offset-assert 0) ;; guessed by decompiler
|
|
(justify-right symbol :offset-assert 4) ;; guessed by decompiler
|
|
(global-flags uint32 :offset-assert 8)
|
|
(draw-pos vector4w :inline :offset-assert 16)
|
|
(mat matrix :inline :offset-assert 32)
|
|
(corner vector 4 :offset-assert 96) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa0
|
|
:flag-assert #x9000000a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype minimap (structure)
|
|
((draw-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(draw2-tmpl dma-gif-packet :inline :offset-assert 32)
|
|
(draw3-tmpl dma-gif-packet :inline :offset-assert 64)
|
|
(draw4-tmpl dma-gif-packet :inline :offset-assert 96)
|
|
(sprite-tmpl dma-gif-packet :inline :offset-assert 128)
|
|
(adgif-tmpl dma-gif-packet :inline :offset-assert 160)
|
|
(color vector4w :inline :offset-assert 192)
|
|
(offset vector :inline :offset-assert 208)
|
|
(minimap-corner vector :inline :offset-assert 224)
|
|
(last-name string :offset-assert 240) ;; guessed by decompiler
|
|
(last-tex basic :offset-assert 244)
|
|
(target-inv-scale float :offset-assert 248)
|
|
(map-bits uint64 :offset-assert 256)
|
|
(level level :offset-assert 264) ;; guessed by decompiler
|
|
(ctywide level :offset-assert 268) ;; guessed by decompiler
|
|
(meters-per-texel float :offset-assert 272)
|
|
(pos-scale float :offset-assert 276)
|
|
(min-inv-scale float :offset-assert 280)
|
|
(max-inv-scale float :offset-assert 284)
|
|
(inv-scale float :offset-assert 212)
|
|
(map-inv-scale float :offset-assert 288)
|
|
(icon-inv-scale float :offset-assert 292)
|
|
(fade float :offset-assert 220)
|
|
(engine engine-minimap :offset-assert 296) ;; guessed by decompiler
|
|
(engine-key uint32 :offset-assert 300)
|
|
(trail minimap-trail 6 :offset-assert 304) ;; guessed by decompiler
|
|
(race-tex texture :offset-assert 1552) ;; guessed by decompiler
|
|
(race-scale float :offset-assert 1556)
|
|
(race-level level :offset-assert 1560) ;; guessed by decompiler
|
|
(sprite2-tmpl dma-gif-packet :inline :offset-assert 1568)
|
|
(race-corner vector :inline :offset-assert 1600)
|
|
(goal-time float :offset-assert 1616)
|
|
(frustum-alpha float :offset-assert 1620)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #x658
|
|
:flag-assert #x1c00000658
|
|
(:methods
|
|
(minimap-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(minimap-method-10 () none) ;; 10 ;; (get-trail-for-connection (_type_ connection-minimap symbol) minimap-trail 10)
|
|
(minimap-method-11 () none) ;; 11 ;; (get-icon-draw-pos (_type_ connection-minimap minimap-trail vector float vector) symbol 11)
|
|
(minimap-method-12 () none) ;; 12 ;; (add-icon! (_type_ process uint int vector int) connection-minimap 12)
|
|
(minimap-method-13 () none) ;; 13 ;; (free-trail-by-connection (_type_ connection-minimap) none 13)
|
|
(minimap-method-14 () none) ;; 14 ;; (update-trails (_type_) none 14)
|
|
(minimap-method-15 () none) ;; 15 ;; (draw-1 (_type_ dma-buffer vector4w symbol) none 15)
|
|
(minimap-method-16 () none) ;; 16 ;; (draw-connection (_type_ minimap-draw-work connection-minimap) none 16)
|
|
(minimap-method-17 () none) ;; 17 ;; (draw-frustum-1 (_type_ minimap-draw-work connection-minimap) none 17)
|
|
(minimap-method-18 () none) ;; 18 ;; (draw-frustum-2 (_type_ minimap-draw-work connection-minimap) none 18)
|
|
(minimap-method-19 () none) ;; 19 ;; (sub-draw-1-2 (_type_ minimap-draw-work) none 19)
|
|
(minimap-method-20 () none) ;; 20 ;; (update! (_type_) symbol 20)
|
|
(minimap-method-21 () none) ;; 21 ;; (sub-draw-1-1 (_type_ minimap-draw-work) none 21)
|
|
(minimap-method-22 () none) ;; 22 ;; (set-color (_type_ vector) none 22)
|
|
(minimap-method-23 () none) ;; 23 ;; (draw-racer-2 (_type_ minimap-draw-work connection-minimap) none 23)
|
|
(minimap-method-24 () none) ;; 24 ;; (draw-sprite2 (_type_ dma-buffer vector4w symbol) none 24)
|
|
(minimap-method-25 () none) ;; 25 ;; (set-race-texture (_type_ texture float level) none 25)
|
|
(minimap-method-26 () none) ;; 26 ;; (draw-racer-1 (_type_ minimap-draw-work connection-minimap float float float) none 26)
|
|
(minimap-method-27 () none) ;; 27 ;; (set-race-corner (_type_ float float) none 27)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-mesh-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-mesh-work-debug (structure)
|
|
((debug-vec1 vector :inline :offset-assert 0)
|
|
(debug-vec2 vector :inline :offset-assert 16)
|
|
(debug-vec3 vector :inline :offset-assert 32)
|
|
(debug-vec4 vector :inline :offset-assert 48)
|
|
(debug-vec5 vector :inline :offset-assert 64)
|
|
(debug-vec6 vector :inline :offset-assert 80)
|
|
(debug-vec7 vector :inline :offset-assert 96)
|
|
(debug-vec8 vector :inline :offset-assert 112)
|
|
(debug-vec9 vector :inline :offset-assert 128)
|
|
(debug-vec10 vector :inline :offset-assert 144)
|
|
(debug-vec11 vector :inline :offset-assert 160)
|
|
(debug-vec12 vector :inline :offset-assert 176)
|
|
(sphere-array sphere 16 :offset-assert 192) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c0
|
|
:flag-assert #x9000001c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-work (structure)
|
|
((vert0-table int8 4 :offset-assert 0) ;; guessed by decompiler
|
|
(vert1-table int8 4 :offset-assert 4) ;; guessed by decompiler
|
|
(edge-mask-table uint8 3 :offset-assert 8) ;; guessed by decompiler
|
|
(pad0 uint32 :offset-assert 12)
|
|
(deg-to-rad float :offset-assert 16)
|
|
(rad-to-deg float :offset-assert 20)
|
|
(nav-poly-min-dist float :offset-assert 24)
|
|
(nav-poly-epsilon float :offset-assert 28)
|
|
(sphere-array sphere 16 :offset-assert 32) ;; guessed by decompiler
|
|
(debug nav-mesh-work-debug :offset-assert 288)
|
|
(work-struct-in-scratch int8 :offset-assert 292)
|
|
(mesh-struct-in-scratch int8 :offset-assert 293)
|
|
(polys-in-scratch int8 :offset-assert 294)
|
|
(mesh nav-mesh :offset-assert 296) ;; guessed by decompiler
|
|
(nav basic :offset-assert 300)
|
|
(poly0 nav-poly :offset-assert 304) ;; guessed by decompiler
|
|
(poly1 nav-poly :offset-assert 308) ;; guessed by decompiler
|
|
(poly-id int32 :offset-assert 312)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x13c
|
|
:flag-assert #x90000013c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-link (structure)
|
|
((id uint32 :offset-assert 0)
|
|
(dest-mesh-id uint32 :offset-assert 4)
|
|
(src-link-poly-id uint8 :offset-assert 8)
|
|
(src-switch-poly-id uint8 :offset-assert 9)
|
|
(dest-link-poly-id uint8 :offset-assert 10)
|
|
(dest-switch-poly-id uint8 :offset-assert 11)
|
|
(dest-mesh nav-mesh :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-poly (structure)
|
|
((data uint8 64 :offset-assert 0) ;; guessed by decompiler
|
|
(vertex vector 4 :offset-assert 0) ;; guessed by decompiler
|
|
(vertex0 vector :inline :offset-assert 0)
|
|
(vertex1 vector :inline :offset-assert 16)
|
|
(vertex2 vector :inline :offset-assert 32)
|
|
(vertex3 vector :inline :offset-assert 48)
|
|
(id uint8 :offset-assert 12)
|
|
(pat uint8 :offset-assert 13)
|
|
(vertex-count uint8 :offset-assert 14)
|
|
(link uint8 :offset-assert 15)
|
|
(adj-poly uint8 4 :offset-assert 28) ;; guessed by decompiler
|
|
(adj-poly0 uint8 :offset-assert 28)
|
|
(adj-poly1 uint8 :offset-assert 29)
|
|
(adj-poly2 uint8 :offset-assert 30)
|
|
(adj-poly3 uint8 :offset-assert 31)
|
|
(min-y float :offset-assert 44)
|
|
(max-y float :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-vertex (vector)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-sphere (structure)
|
|
((trans sphere :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-ray (structure)
|
|
((current-pos vector :inline :offset-assert 0)
|
|
(dir vector :inline :offset-assert 16)
|
|
(dest-pos vector :inline :offset-assert 32)
|
|
(current-poly nav-poly :offset-assert 48)
|
|
(next-poly nav-poly :offset-assert 52)
|
|
(len meters :offset-assert 56)
|
|
(last-edge int8 :offset-assert 60)
|
|
(ignore uint8 :offset-assert 61)
|
|
(terminated symbol :offset-assert 64) ;; guessed by decompiler
|
|
(reached-dest symbol :offset-assert 68) ;; guessed by decompiler
|
|
(hit-boundary symbol :offset-assert 72) ;; guessed by decompiler
|
|
(hit-gap symbol :offset-assert 76) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-route-portal (structure)
|
|
((vertex nav-vertex 2 :offset-assert 0) ;; guessed by decompiler
|
|
(next-poly nav-poly :offset-assert 32)
|
|
(edge-index int8 :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x25
|
|
:flag-assert #x900000025
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-find-poly-parms (structure)
|
|
((point vector :inline :offset-assert 0)
|
|
(y-threshold float :offset-assert 16)
|
|
(ignore uint8 :offset-assert 20)
|
|
(poly nav-poly :offset-assert 24)
|
|
(dist float :offset-assert 28)
|
|
(point-inside? symbol :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clamp-travel-vector-to-mesh-return-info (structure)
|
|
((found-boundary symbol :offset-assert 0) ;; guessed by decompiler
|
|
(intersection vector :inline :offset-assert 16)
|
|
(boundary-normal vector :inline :offset-assert 32)
|
|
(prev-normal vector :inline :offset-assert 48)
|
|
(next-normal vector :inline :offset-assert 64)
|
|
(poly nav-poly :offset-assert 80)
|
|
(gap-poly nav-poly :offset-assert 84)
|
|
(edge int8 :offset-assert 88)
|
|
(ignore uint8 :offset-assert 89)
|
|
(vert-prev vector :inline :offset-assert 96)
|
|
(vert-0 vector :inline :offset-assert 112)
|
|
(vert-1 vector :inline :offset-assert 128)
|
|
(vert-next vector :inline :offset-assert 144)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa0
|
|
:flag-assert #x9000000a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh (basic)
|
|
((work nav-mesh-work :offset-assert 4)
|
|
(poly-array (inline-array nav-poly) :offset-assert 8) ;; guessed by decompiler
|
|
(static-sphere-count uint8 :offset-assert 12)
|
|
(poly-count uint8 :offset-assert 13)
|
|
(nav-control-count uint8 :offset-assert 14)
|
|
(max-nav-control-count uint8 :offset-assert 15)
|
|
(route (pointer nav-poly) :offset-assert 16) ;; guessed by decompiler
|
|
(poly-hash grid-hash :offset-assert 20) ;; guessed by decompiler
|
|
(nav-control-array (inline-array nav-control) :offset-assert 24) ;; guessed by decompiler
|
|
(sphere-hash sphere-hash :offset-assert 28) ;; guessed by decompiler
|
|
(static-sphere (inline-array sphere) :offset-assert 32) ;; guessed by decompiler
|
|
(user-list engine :offset-assert 36) ;; guessed by decompiler
|
|
(next-nav-mesh surface :offset-assert 40) ;; guessed by decompiler
|
|
(prev-nav-mesh surface :offset-assert 44) ;; guessed by decompiler
|
|
(bounds sphere :inline :offset-assert 48) ;; vector :inline
|
|
(origin vector :inline :offset-assert 48)
|
|
(entity entity :offset-assert 64) ;; guessed by decompiler
|
|
(link-array (inline-array nav-mesh-link) :offset-assert 68) ;; guessed by decompiler
|
|
(link-count uint8 :offset-assert 72)
|
|
(flags nav-mesh-flag :offset-assert 73)
|
|
(pad1 uint8 2 :offset-assert 74) ;; guessed by decompiler
|
|
(nearest-y-threshold meters :offset-assert 76)
|
|
(water-max-height meters :offset-assert 80)
|
|
(pad2 uint32 7 :offset-assert 84) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 50
|
|
:size-assert #x70
|
|
:flag-assert #x3200000070
|
|
;; field nav-mesh-flag is likely a value type.
|
|
(:methods
|
|
(nav-mesh-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(nav-mesh-method-10 () none) ;; 10 ;; (nav-mesh-method-10 (_type_ vector vector nav-poly) nav-poly 10)
|
|
(nav-mesh-method-11 () none) ;; 11 ;; (poly-centroid (_type_ nav-poly vector) vector 11)
|
|
(nav-mesh-method-12 () none) ;; 12 ;; (poly-centroid-local (_type_ nav-poly vector) vector 12)
|
|
(nav-mesh-method-13 () none) ;; 13 ;; (lookup-poly-on-route-to-target (_type_ nav-poly nav-poly) nav-poly 13)
|
|
(nav-mesh-method-14 () none) ;; 14 ;; (get-route-portal (_type_ nav-poly nav-poly nav-route-portal) (inline-array nav-vertex) 14)
|
|
(nav-mesh-method-15 () none) ;; 15 ;; (initialize-mesh! (_type_) none 15)
|
|
(nav-mesh-method-16 () none) ;; 16 ;; (move-along-nav-ray! (_type_ nav-ray) none 16)
|
|
(nav-mesh-method-17 () none) ;; 17 ;; (try-move-along-ray (_type_ nav-poly vector vector float) meters 17)
|
|
(nav-mesh-method-18 () none) ;; 18 ;; (clamp-vector-to-mesh-cross-gaps (_type_ vector nav-poly vector float symbol clamp-travel-vector-to-mesh-return-info) none 18)
|
|
(nav-mesh-method-19 () none) ;; 19 ;; (clamp-vector-to-mesh-no-gaps (_type_ vector nav-poly vector clamp-travel-vector-to-mesh-return-info) none 19)
|
|
(nav-mesh-method-20 () none) ;; 20 ;; (set-normals-from-adjacent-bounds (_type_ clamp-travel-vector-to-mesh-return-info) none 20)
|
|
(nav-mesh-method-21 () none) ;; 21 ;; (find-adjacent-bounds-one (_type_ vector nav-poly int int) none 21)
|
|
(nav-mesh-method-22 () none) ;; 22 ;; (compute-bounding-box-from-vertices (_type_ vector vector) none 22)
|
|
(nav-mesh-method-23 () none) ;; 23 ;; (init-from-entity (_type_ entity-nav-mesh) none 23)
|
|
(nav-mesh-method-24 () none) ;; 24 ;; (handle-birth (_type_) none 24)
|
|
(nav-mesh-method-25 () none) ;; 25 ;; (handle-kill (_type_) none 25)
|
|
(nav-mesh-method-26 () none) ;; 26 ;; (update-navigation (_type_) none 26)
|
|
(nav-mesh-method-27 () none) ;; 27 ;; (new-nav-control (_type_ process-drawable) nav-control 27)
|
|
(nav-mesh-method-28 () none) ;; 28 ;; (remove-nav-control (_type_ nav-control) none 28)
|
|
(nav-mesh-method-29 () none) ;; 29 ;; (add-process-drawable-to-navmesh (_type_ process-drawable symbol) none 29)
|
|
(nav-mesh-method-30 () none) ;; 30 ;; (remove-process-drawable (_type_ process-drawable) none 30)
|
|
(nav-mesh-method-31 () none) ;; 31 ;; (change-to (_type_ process-drawable) none 31)
|
|
(nav-mesh-method-32 () none) ;; 32 ;; (link-by-id (_type_ uint) symbol 32)
|
|
(nav-mesh-method-33 () none) ;; 33 ;; (unlink-by-id (_type_ uint) symbol 33)
|
|
(nav-mesh-method-34 () none) ;; 34 ;; (nav-mesh-method-34 (_type_ vector vector float) float 34)
|
|
(nav-mesh-method-35 () none) ;; 35 ;; (nav-mesh-method-35 (_type_ vector vector float) float 35)
|
|
(nav-mesh-method-36 () none) ;; 36 ;; (debug-draw-poly (_type_ nav-poly rgba) none 36)
|
|
(nav-mesh-method-37 () none) ;; 37 ;; (point-in-poly? (_type_ nav-poly vector) symbol 37)
|
|
(nav-mesh-method-38 () none) ;; 38 ;; (nav-mesh-method-38 (_type_ nav-poly vector vector vector (pointer nav-poly)) vector 38)
|
|
(nav-mesh-method-39 () none) ;; 39 ;; (closest-point-on-boundary (_type_ nav-poly vector vector) none 39)
|
|
(nav-mesh-method-40 () none) ;; 40 ;; (project-point-onto-plane-of-poly-local (_type_ nav-poly vector vector vector) none 40)
|
|
(nav-mesh-method-41 () none) ;; 41 ;; (project-point-into-poly-2d (_type_ nav-poly vector vector) none 41)
|
|
(nav-mesh-method-42 () none) ;; 42 ;; (find-poly-containing-point-local (_type_ nav-find-poly-parms) nav-poly 42)
|
|
(nav-mesh-method-43 () none) ;; 43 ;; (find-nearest-poly-to-point-local (_type_ nav-find-poly-parms) nav-find-poly-parms 43)
|
|
(nav-mesh-method-44 () none) ;; 44 ;; (is-in-mesh-local? (_type_ vector float float) symbol 44)
|
|
(nav-mesh-method-45 () none) ;; 45 ;; (link-to-other-mesh (_type_ nav-mesh-link) symbol 45)
|
|
(nav-mesh-method-46 () none) ;; 46 ;; (unlink-mesh (_type_ nav-mesh-link) none 46)
|
|
(nav-mesh-method-47 () none) ;; 47
|
|
(nav-mesh-method-48 () none) ;; 48
|
|
(nav-mesh-method-49 () none) ;; 49
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern vector-normalize-unity! function) ;; (function vector vector)
|
|
;; (define-extern vector-normalize-unity-copy! function) ;; (function vector vector vector)
|
|
;; (define-extern debug-validate-current-poly function) ;; (function symbol)
|
|
;; (define-extern init-ray function) ;; (function nav-ray none)
|
|
;; (define-extern point-poly-intersection? function) ;; (function nav-mesh vector int (inline-array vector) symbol)
|
|
;; (define-extern nav-sphere-from-cam function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bigmap-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bigmap-image (structure)
|
|
((clut-offset uint32 :offset-assert 0)
|
|
(image-offset uint32 :offset-assert 4)
|
|
(width uint32 :offset-assert 8)
|
|
(height uint32 :offset-assert 12)
|
|
(data uint8 1 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x11
|
|
:flag-assert #x900000011
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bigmap-info (vector)
|
|
((scale float :offset-assert 8)
|
|
(inv-scale float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bigmap-info-array (structure)
|
|
((data bigmap-info 24 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x180
|
|
:flag-assert #x900000180
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bigmap (basic)
|
|
((drawing-flag symbol :offset-assert 4) ;; guessed by decompiler
|
|
(loading-flag symbol :offset-assert 8) ;; guessed by decompiler
|
|
(bigmap-index uint32 :offset-assert 12)
|
|
(bigmap-image external-art-buffer :offset-assert 16) ;; guessed by decompiler
|
|
(tpage external-art-buffer :offset-assert 20) ;; guessed by decompiler
|
|
(tpage2 basic :offset-assert 24)
|
|
(progress-minimap texture-page :offset-assert 28) ;; guessed by decompiler
|
|
(progress-minimap2 basic :offset-assert 32)
|
|
(load-index uint32 :offset-assert 36)
|
|
(x0 int32 :offset-assert 40)
|
|
(y0 int32 :offset-assert 44)
|
|
(x1 int32 :offset-assert 48)
|
|
(y1 int32 :offset-assert 52)
|
|
(goal-time float :offset-assert 56)
|
|
(sprite-tmpl dma-gif-packet :inline :offset-assert 64)
|
|
(draw-tmpl dma-gif-packet :inline :offset-assert 96)
|
|
(adgif-tmpl dma-gif-packet :inline :offset-assert 128)
|
|
(offset vector :inline :offset-assert 160)
|
|
(size float :offset-assert 168)
|
|
(scale float :offset-assert 172)
|
|
(scroll vector :inline :offset-assert 176)
|
|
(pos vector4w :inline :offset-assert 192)
|
|
(color vector4w :inline :offset-assert 208)
|
|
(corner vector 4 :offset-assert 224) ;; guessed by decompiler
|
|
(auto-save-icon-flag symbol :offset-assert 288) ;; guessed by decompiler
|
|
(global-flags uint32 :offset-assert 292)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x128
|
|
:flag-assert #x1700000128
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(bigmap-method-9 () none) ;; 9 ;; (initialize (_type_) none 9)
|
|
(bigmap-method-10 () none) ;; 10 ;; (update (_type_) none 10)
|
|
(bigmap-method-11 () none) ;; 11 ;; (draw (_type_ int int int int) int 11)
|
|
(bigmap-method-12 () none) ;; 12 ;; (handle-cpad-inputs (_type_) int 12)
|
|
(bigmap-method-13 () none) ;; 13 ;; (compress-all (_type_) int 13)
|
|
(bigmap-method-14 () none) ;; 14 ;; (enable-drawing (_type_) none 14)
|
|
(bigmap-method-15 () none) ;; 15 ;; (disable-drawing (_type_) int 15)
|
|
(bigmap-method-16 () none) ;; 16 ;; (dump-to-file (_type_) file-stream 16)
|
|
(bigmap-method-17 () none) ;; 17 ;; (set-pos! (_type_ vector) int 17)
|
|
(bigmap-method-18 () none) ;; 18 ;; (decompress-current-masks! (_type_) int 18)
|
|
(bigmap-method-19 () none) ;; 19 ;; (compress-current-masks! (_type_) int 19)
|
|
(bigmap-method-20 () none) ;; 20 ;; (set-enable-from-position! (_type_) int 20)
|
|
(bigmap-method-21 () none) ;; 21 ;; (maybe-fill-for-position (_type_ int int) int 21)
|
|
(bigmap-method-22 () none) ;; 22 ;; (texture-upload-dma (_type_ dma-buffer (pointer uint32) int int int gs-psm) none 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; settings-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype user-setting-data (structure)
|
|
((border-mode symbol :offset-assert 0) ;; guessed by decompiler
|
|
(process-mask process-mask :offset-assert 4) ;; guessed by decompiler
|
|
(language uint8 :offset-assert 12) ;; language-enum
|
|
(movie (pointer process) :offset-assert 32) ;; guessed by decompiler
|
|
(talking (pointer process) :offset-assert 36) ;; guessed by decompiler
|
|
(spooling (pointer process) :offset-assert 40) ;; guessed by decompiler
|
|
(hint (pointer process) :offset-assert 44) ;; guessed by decompiler
|
|
(ambient (pointer process) :offset-assert 48) ;; guessed by decompiler
|
|
(video-mode symbol :offset-assert 52) ;; guessed by decompiler
|
|
(aspect-ratio symbol :offset-assert 56) ;; guessed by decompiler
|
|
(auto-save symbol :offset-assert 64) ;; guessed by decompiler
|
|
(bg-r float :offset-assert 68)
|
|
(bg-g float :offset-assert 72)
|
|
(bg-b float :offset-assert 76)
|
|
(bg-a float :offset-assert 80)
|
|
(bg-a-speed float :offset-assert 84)
|
|
(bg-a-force float :offset-assert 88)
|
|
(blur-a float :offset-assert 92)
|
|
(blur-a-speed float :offset-assert 96)
|
|
(allow-progress symbol :offset-assert 100) ;; guessed by decompiler
|
|
(allow-pause symbol :offset-assert 104) ;; guessed by decompiler
|
|
(movie-name symbol :offset-assert 120) ;; guessed by decompiler
|
|
(weather symbol :offset-assert 124) ;; guessed by decompiler
|
|
(task-mask task-mask :offset-assert 140)
|
|
(duck symbol :offset-assert 148) ;; guessed by decompiler
|
|
(attack symbol :offset-assert 152) ;; guessed by decompiler
|
|
(gun symbol :offset-assert 156) ;; guessed by decompiler
|
|
(board symbol :offset-assert 160) ;; guessed by decompiler
|
|
(jump symbol :offset-assert 164) ;; guessed by decompiler
|
|
(speed-mult float :offset-assert 168)
|
|
(features uint64 :offset-assert 176) ;; game-feature
|
|
(vehicles uint64 :offset-assert 184)
|
|
(sfx-volume float :offset-assert 192)
|
|
(sfx-volume-movie float :offset-assert 196)
|
|
(music-volume float :offset-assert 200)
|
|
(music-volume-movie float :offset-assert 204)
|
|
(dialog-volume float :offset-assert 208)
|
|
(dialog-volume-talker float :offset-assert 212)
|
|
(ambient-volume float :offset-assert 216)
|
|
(ambient-volume-movie float :offset-assert 220)
|
|
(dynamic-ambient-volume float :offset-assert 224)
|
|
(talker-volume float :offset-assert 228)
|
|
(sound-flava uint8 :offset-assert 232)
|
|
(sound-flava-priority float :offset-assert 236)
|
|
(mode-sound-bank uint32 :offset-assert 240) ;; guessed by decompiler
|
|
(sound-excitement float :offset-assert 244)
|
|
(sound-reverb float :offset-assert 248)
|
|
(stereo-mode int32 :offset-assert 252)
|
|
(music symbol :offset-assert 256) ;; guessed by decompiler
|
|
(sound-stinger int32 :offset-assert 260)
|
|
(spool-anim spool-anim :offset-assert 264) ;; guessed by decompiler
|
|
(sound-mode uint32 :offset-assert 268)
|
|
(task-manager (pointer process) :offset-assert 272) ;; guessed by decompiler
|
|
(task symbol :offset-assert 276) ;; guessed by decompiler
|
|
(airlock symbol :offset-assert 280) ;; guessed by decompiler
|
|
(minimap uint16 :offset-assert 284) ;; guessed by decompiler
|
|
(sound-tune uint32 :offset-assert 288)
|
|
(allow-continue symbol :offset-assert 292) ;; guessed by decompiler
|
|
(subtitle symbol :offset-assert 304) ;; guessed by decompiler
|
|
(doorway symbol :offset-assert 308) ;; guessed by decompiler
|
|
(gem symbol :offset-assert 312) ;; guessed by decompiler
|
|
(half-speed symbol :offset-assert 316) ;; guessed by decompiler
|
|
(gun-buoy symbol :offset-assert 320) ;; guessed by decompiler
|
|
(double-jump symbol :offset-assert 324) ;; guessed by decompiler
|
|
(pilot symbol :offset-assert 328) ;; guessed by decompiler
|
|
(pilot-exit symbol :offset-assert 332) ;; guessed by decompiler
|
|
(pilot-death basic :offset-assert 336)
|
|
(speech-control symbol :offset-assert 340) ;; guessed by decompiler
|
|
(vehicle-hijacking symbol :offset-assert 344) ;; guessed by decompiler
|
|
(darkjak symbol :offset-assert 348) ;; guessed by decompiler
|
|
(lightjak basic :offset-assert 352)
|
|
(endlessfall symbol :offset-assert 356) ;; guessed by decompiler
|
|
(rain float :offset-assert 360)
|
|
(snow float :offset-assert 364)
|
|
(exclusive-load symbol :offset-assert 368) ;; guessed by decompiler
|
|
(render symbol :offset-assert 372) ;; guessed by decompiler
|
|
(allow-timeout symbol :offset-assert 376) ;; guessed by decompiler
|
|
(mirror symbol :offset-assert 380) ;; guessed by decompiler
|
|
(movie-skip-frame float :offset-assert 384)
|
|
(allow-blackout symbol :offset-assert 388) ;; guessed by decompiler
|
|
(race-minimap int32 :offset-assert 392)
|
|
(beard symbol :offset-assert 396) ;; guessed by decompiler
|
|
(ignore-target symbol :offset-assert 400) ;; guessed by decompiler
|
|
(subtitle-language uint8 :offset-assert 404) ;; language-enum
|
|
(sound-bank-load symbol :offset-assert 408) ;; guessed by decompiler
|
|
(allow-error symbol :offset-assert 412) ;; guessed by decompiler
|
|
(under-water-pitch-mod float :offset-assert 416)
|
|
(slow-time float :offset-assert 420)
|
|
(restart-info basic :offset-assert 428)
|
|
(fail-info basic :offset-assert 432)
|
|
(death-info basic :offset-assert 436)
|
|
(quit-info basic :offset-assert 440)
|
|
(extra-bank-count uint32 :offset-assert 444)
|
|
(extra-bank pair 3 :offset-assert 448) ;; guessed by decompiler
|
|
(borrow-count uint32 :offset-assert 460)
|
|
(borrow pair 3 :offset-assert 464) ;; guessed by decompiler
|
|
(exclusive-task-count uint32 :offset-assert 476)
|
|
(exclusive-task int32 3 :offset-assert 480) ;; guessed by decompiler
|
|
(level-trans-time int32 :offset-assert 492)
|
|
(scarf float :offset-assert 496)
|
|
(goggles float :offset-assert 500)
|
|
(board-trail basic :offset-assert 504)
|
|
(letterbox float :offset-assert 572)
|
|
(letterbox-speed float :offset-assert 576)
|
|
(borrow-city-count uint32 :offset-assert 620)
|
|
(borrow-city UNKNOWN 3 :offset-assert 624)
|
|
(audio-language uint8 :offset-assert 748)
|
|
(special-volume float :offset-assert 796)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x38c
|
|
:flag-assert #xb0000038c
|
|
(:methods
|
|
(user-setting-data-method-9 () none) ;; 9 ;; (user-setting-data-method-9 (_type_ engine engine-pers engine) user-setting-data 9)
|
|
(user-setting-data-method-10 () none) ;; 10 ;; (user-setting-data-method-10 (_type_ object symbol float uint) user-setting-data 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-setting-data (structure)
|
|
((fov deg :offset-assert 0) ;; degrees
|
|
(pov-handle uint64 :offset-assert 16) ;; handle
|
|
(pov-bone int32 :offset-assert 24)
|
|
(pov-offset vector :inline :offset-assert 32)
|
|
(string-default boolean :offset-assert 48) ;; symbol
|
|
(string-max-length meters :offset-assert 52)
|
|
(string-min-length meters :offset-assert 56)
|
|
(string-max-height meters :offset-assert 60)
|
|
(string-min-height meters :offset-assert 64)
|
|
(string-cliff-height meters :offset-assert 68)
|
|
(string-camera-floor meters :offset-assert 72)
|
|
(string-camera-ceiling meters :offset-assert 76)
|
|
(gun-max-height meters :offset-assert 80)
|
|
(gun-min-height meters :offset-assert 84)
|
|
(string-local-down vector :inline :offset-assert 96)
|
|
(slave-options cam-slave-options :offset-assert 112)
|
|
(matrix-blend-max-angle deg :offset-assert 120) ;; degrees
|
|
(matrix-blend-max-partial float :offset-assert 124)
|
|
(string-spline-max-move meters :offset-assert 128)
|
|
(string-spline-accel meters :offset-assert 132)
|
|
(string-spline-max-move-player meters :offset-assert 136)
|
|
(string-spline-accel-player meters :offset-assert 140)
|
|
(string-startup-vector vector :inline :offset-assert 144)
|
|
(use-string-startup-vector basic :offset-assert 160)
|
|
(look-at-point vector :inline :offset-assert 176)
|
|
(use-look-at-point symbol :offset-assert 192) ;; guessed by decompiler
|
|
(target-height meters :offset-assert 196)
|
|
(foot-offset meters :offset-assert 200)
|
|
(head-offset meters :offset-assert 204)
|
|
(teleport-on-entity-change boolean :offset-assert 208) ;; symbol
|
|
(entity-name string :offset-assert 212)
|
|
(cam-slope string :offset-assert 216)
|
|
(entity-or-mode-changed boolean :offset-assert 220) ;; symbol
|
|
(master-options cam-master-options :offset-assert 224)
|
|
(entity-mask uint32 :offset-assert 232)
|
|
(mode-name symbol :offset-assert 236) ;; guessed by decompiler
|
|
(real-entity-name string :offset-assert 240)
|
|
(cam-mode symbol :offset-assert 244) ;; guessed by decompiler
|
|
(interp-time uint32 :offset-assert 248)
|
|
(no-intro symbol :offset-assert 252) ;; guessed by decompiler
|
|
(use-point-of-interest symbol :offset-assert 256) ;; guessed by decompiler
|
|
(point-of-interest vector :inline :offset-assert 272)
|
|
(handle-of-interest uint64 :offset-assert 288) ;; handle
|
|
(mouse-tumble-point vector :inline :offset-assert 304)
|
|
(use-mouse-tumble-point symbol :offset-assert 320) ;; guessed by decompiler
|
|
(mouse-input symbol :offset-assert 324) ;; guessed by decompiler
|
|
(cpad1-skip-buttons symbol :offset-assert 328) ;; guessed by decompiler
|
|
(butt-handle uint64 :offset-assert 336) ;; handle
|
|
(butt-angle float :offset-assert 344)
|
|
(extra-follow-height float :offset-assert 348)
|
|
(interp-time-priority uint32 :offset-assert 352)
|
|
(string-max-length-default symbol :offset-assert 356) ;; guessed by decompiler
|
|
(string-min-length-default symbol :offset-assert 360) ;; guessed by decompiler
|
|
(string-max-height-default symbol :offset-assert 364) ;; guessed by decompiler
|
|
(string-min-height-default symbol :offset-assert 368) ;; guessed by decompiler
|
|
(flip-vertical basic :offset-assert 372)
|
|
(flip-horizontal basic :offset-assert 376)
|
|
(fov-priority float :offset-assert 384)
|
|
(dummy object 98 :offset-assert 388) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x30c
|
|
:flag-assert #xb0000030c
|
|
;; field cam-slave-options is likely a value type. field cam-master-options is likely a value type.
|
|
(:methods
|
|
(cam-setting-data-method-9 () none) ;; 9 ;; (cam-setting-data-method-9 (_type_ engine engine-pers engine) _type_ 9)
|
|
(cam-setting-data-method-10 () none) ;; 10 ;; (cam-setting-data-method-10 (_type_ object (pointer process) float int) _type_ 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype setting-control (basic)
|
|
((user-current user-setting-data :inline :offset-assert 16)
|
|
(user-target user-setting-data :inline :offset-assert 928)
|
|
(user-default user-setting-data :inline :offset-assert 1840)
|
|
(cam-current cam-setting-data :inline :offset-assert 2752)
|
|
(cam-target cam-setting-data :inline :offset-assert 3536)
|
|
(cam-default cam-setting-data :inline :offset-assert 4320)
|
|
(engine engine :offset-assert 5100) ;; guessed by decompiler
|
|
(engine-pers engine-pers :offset-assert 5104) ;; guessed by decompiler
|
|
(engine-hi engine :offset-assert 5108) ;; guessed by decompiler
|
|
(sound-stinger-time uint64 :offset-assert 5112) ;; time-frame
|
|
(sound-stinger-change-time time-frame 4 :offset-assert 5120) ;; guessed by decompiler
|
|
(sound-excitement-change-time uint64 :offset-assert 5152) ;; time-frame
|
|
(sound-excitement-targ float :offset-assert 5160)
|
|
(sound-excitement-level uint32 :offset-assert 5164)
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x1430
|
|
:flag-assert #x1400001430
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(setting-control-method-9 () none) ;; 9 ;; (add-setting (_type_ process symbol object object object) none 9)
|
|
(setting-control-method-10 () none) ;; 10 ;; (persist-with-delay (_type_ symbol time-frame symbol symbol float int) none 10)
|
|
(setting-control-method-11 () none) ;; 11 ;; (set-setting (_type_ process symbol object object object) none 11)
|
|
(setting-control-method-12 () none) ;; 12 ;; (remove-setting (_type_ process symbol) none 12)
|
|
(setting-control-method-13 () none) ;; 13 ;; (kill-persister (_type_ engine-pers object) none 13)
|
|
(setting-control-method-14 () none) ;; 14 ;; (setting-control-method-14 (_type_ object) connectable 14)
|
|
(setting-control-method-15 () none) ;; 15 ;; (remove-setting-by-arg0 (_type_ object) none 15)
|
|
(setting-control-method-16 () none) ;; 16 ;; (set-setting-by-param (_type_ symbol object object object) connection 16)
|
|
(setting-control-method-17 () none) ;; 17 ;; (apply-settings (_type_) user-setting-data 17)
|
|
(setting-control-method-18 () none) ;; 18 ;; (update (_type_) user-setting-data 18)
|
|
(setting-control-method-19 () none) ;; 19
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bigmap ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *bigmap-info-array* object) ;; bigmap-info-array
|
|
;; (define-extern *bigmap* object) ;; bigmap
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype target (process-focusable)
|
|
((control control-info :offset-assert 128) ;; guessed by decompiler
|
|
(skel2 joint-control :offset-assert 208) ;; guessed by decompiler
|
|
(shadow-backup shadow-geo :offset-assert 212) ;; guessed by decompiler
|
|
(target-flags uint32 :offset-assert 188)
|
|
(game game-info :offset-assert 216) ;; guessed by decompiler
|
|
(neck joint-mod :offset-assert 220) ;; guessed by decompiler
|
|
(head joint-mod :offset-assert 224) ;; guessed by decompiler
|
|
(upper-body joint-mod :offset-assert 228) ;; guessed by decompiler
|
|
(horns joint-mod :offset-assert 232) ;; guessed by decompiler
|
|
(hair joint-mod 2 :offset-assert 236) ;; guessed by decompiler
|
|
(arm-ik joint-mod-ik 2 :offset-assert 244) ;; guessed by decompiler
|
|
(leg-ik joint-mod-ik 2 :offset-assert 252) ;; guessed by decompiler
|
|
(foot joint-mod 2 :offset-assert 260) ;; guessed by decompiler
|
|
(cloth basic :offset-assert 268)
|
|
(init-time uint64 :offset-assert 272) ;; time-frame
|
|
(teleport-time uint64 :offset-assert 280) ;; time-frame
|
|
(state-hook-time uint64 :offset-assert 288) ;; time-frame
|
|
(state-hook (function none :behavior target) :offset-assert 296) ;; guessed by decompiler
|
|
(cam-user-mode symbol :offset-assert 300) ;; guessed by decompiler
|
|
(sidekick (pointer sidekick) :offset-assert 304) ;; guessed by decompiler
|
|
(manipy (pointer manipy) :offset-assert 308) ;; guessed by decompiler
|
|
(mirror (pointer process-drawable) :offset-assert 312) ;; guessed by decompiler
|
|
(attack-info attack-info :inline :offset-assert 320)
|
|
(attack-info-rec attack-info :inline :offset-assert 496)
|
|
(attack-info-old attack-info 8 :offset-assert 672) ;; guessed by decompiler
|
|
(anim-seed uint64 :offset-assert 2080)
|
|
(alt-cam-pos vector :inline :offset-assert 2096)
|
|
(current-level level :offset-assert 2112) ;; guessed by decompiler
|
|
(saved-pos transformq :inline :offset-assert 2128)
|
|
(saved-owner uint64 :offset-assert 2176)
|
|
(alt-neck-pos vector :inline :offset-assert 2192)
|
|
(focus-search (array collide-shape) :offset-assert 2208) ;; guessed by decompiler
|
|
(handle-search basic :offset-assert 2212)
|
|
(excitement float :offset-assert 2216)
|
|
(shock-effect-time uint64 :offset-assert 2224) ;; time-frame
|
|
(beard? symbol :offset-assert 2232) ;; guessed by decompiler
|
|
(spool-anim spool-anim :offset-assert 2236) ;; guessed by decompiler
|
|
(ambient-time uint64 :offset-assert 2240) ;; time-frame
|
|
(fp-hud uint64 :offset-assert 2248) ;; handle
|
|
(no-load-wait uint64 :offset-assert 2256)
|
|
(no-look-around-wait uint64 :offset-assert 2264)
|
|
(burn-proc uint64 :offset-assert 2272) ;; handle
|
|
(pre-joint-hook (function none :behavior target) :offset-assert 2280) ;; guessed by decompiler
|
|
(notify uint64 :offset-assert 2288) ;; handle
|
|
(death-resetter resetter-spec :inline :offset-assert 2296)
|
|
(mode-cache basic :offset-assert 2312)
|
|
(mode-param1 uint64 :offset-assert 2320) ;; handle
|
|
(mode-param2 uint64 :offset-assert 2328)
|
|
(mode-param3 uint64 :offset-assert 2336)
|
|
(major-mode-exit-hook basic :offset-assert 2344)
|
|
(major-mode-event-hook basic :offset-assert 2348)
|
|
(sub-mode-exit-hook basic :offset-assert 2352)
|
|
(ext-geo-control basic :offset-assert 2356)
|
|
(pending-ext-geo int32 :offset-assert 2360)
|
|
(ext-geo int32 :offset-assert 2364)
|
|
(ext-anim-control basic :offset-assert 2368)
|
|
(pending-ext-anim int32 :offset-assert 2372)
|
|
(ext-anim int32 :offset-assert 2376)
|
|
(tobot-state state :offset-assert 2380) ;; guessed by decompiler
|
|
(tobot? symbol :offset-assert 2384) ;; guessed by decompiler
|
|
(tobot-recorder basic :offset-assert 2388)
|
|
(target-effect uint64 :offset-assert 2392)
|
|
(color-effect basic :offset-assert 2400)
|
|
(color-effect-start-time uint64 :offset-assert 2408) ;; time-frame
|
|
(color-effect-duration uint64 :offset-assert 2416)
|
|
(racer racer-info :offset-assert 2424) ;; guessed by decompiler
|
|
(tube tube-info :offset-assert 2428) ;; guessed by decompiler
|
|
(flut flut-info :offset-assert 2432) ;; guessed by decompiler
|
|
(board board-info :offset-assert 2436) ;; guessed by decompiler
|
|
(pilot pilot-info :offset-assert 2440) ;; guessed by decompiler
|
|
(gun gun-info :offset-assert 2444) ;; guessed by decompiler
|
|
(mech mech-info :offset-assert 2448) ;; guessed by decompiler
|
|
(turret turret-info :offset-assert 2452) ;; guessed by decompiler
|
|
(indax indax-info :offset-assert 2456) ;; guessed by decompiler
|
|
(ladder basic :offset-assert 2460)
|
|
(darkjak-interp float :offset-assert 2464)
|
|
(darkjak-interp-old float :offset-assert 2468)
|
|
(darkjak-giant-interp float :offset-assert 2472)
|
|
(darkjak darkjak-info :offset-assert 2476) ;; guessed by decompiler
|
|
(lightjak-interp float :offset-assert 2480)
|
|
(lightjak-interp-old float :offset-assert 2484)
|
|
(lightjak basic :offset-assert 2488)
|
|
(scarf-interp-targ float :offset-assert 2492)
|
|
(scarf-interp float :offset-assert 2496)
|
|
(scarf-interp-old float :offset-assert 2500)
|
|
(goggles-interp-targ float :offset-assert 2504)
|
|
(goggles-interp float :offset-assert 2508)
|
|
(goggles-interp-old float :offset-assert 2512)
|
|
(invisible-interp float :offset-assert 2516)
|
|
(invisible-start-time uint64 :offset-assert 2520)
|
|
(invisible-duration uint64 :offset-assert 2528)
|
|
(invisible-shadow-dir-backup vector :inline :offset-assert 2544)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #xa00
|
|
:flag-assert #x1e09800a00
|
|
;; field mode-param2 uses ~A with a 64-bit load. field mode-param3 uses ~A with a 64-bit load.
|
|
(:methods
|
|
(target-method-28 () none) ;; 28 ;; (init-target (_type_ continue-point symbol) none 28)
|
|
(target-method-29 () none) ;; 29
|
|
)
|
|
(:states
|
|
target-duck-high-jump ;; associated process guessed by decompiler, old: (state float float symbol target)
|
|
target-darkjak-get-on ;; associated process guessed by decompiler, old: (state darkjak-stage target)
|
|
target-darkjak-smack-charge
|
|
target-flop-hit-ground ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-darkjak-get-off ;; associated process guessed by decompiler, old: (state target)
|
|
target-indax-jump ;; associated process guessed by decompiler, old: (state float float surface target)
|
|
target-indax-attack ;; associated process guessed by decompiler, old: (state target)
|
|
target-darkjak-running-attack ;; associated process guessed by decompiler, old: (state target)
|
|
target-hit ;; associated process guessed by decompiler, old: (state symbol attack-info target)
|
|
target-mech-grab ;; associated process guessed by decompiler, old: (state target)
|
|
target-darkjak-smack
|
|
target-duck-high-jump-jump ;; associated process guessed by decompiler, old: (state float float symbol target)
|
|
target-flut-death
|
|
target-lightjak-freeze
|
|
target-attack ;; associated process guessed by decompiler, old: (state target)
|
|
target-title ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-darkjak-bomb0 ;; associated process guessed by decompiler, old: (state target)
|
|
target-double-jump ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-attack-uppercut-jump ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-darkjak-bomb1 ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-indax-falling ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-wade-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-pole-cycle ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-hit-ground-hard ;; associated process guessed by decompiler, old: (state float target)
|
|
target-attack-air ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-lightjak-get-on
|
|
target-wade-walk ;; associated process guessed by decompiler, old: (state target)
|
|
target-swim
|
|
target-credits
|
|
target-continue ;; associated process guessed by decompiler, old: (state continue-point target)
|
|
target-swim-jump ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-load-wait ;; associated process guessed by decompiler, old: (state target)
|
|
target-death ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-duck-walk ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-indax-start ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-indax-hit ;; associated process guessed by decompiler, old: (state symbol attack-info target)
|
|
target-indax-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-indax-walk ;; associated process guessed by decompiler, old: (state target)
|
|
target-indax-double-jump ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-indax-hit-ground ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-mech-start ;; associated process guessed by decompiler, old: (state handle float symbol target)
|
|
target-indax-trip ;; associated process guessed by decompiler, old: (state target)
|
|
target-indax-attack-air ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-indax-running-attack ;; associated process guessed by decompiler, old: (state target)
|
|
target-indax-death ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-indax-get-off
|
|
target-lightjak-swoop-falling
|
|
target-look-around ;; associated process guessed by decompiler, old: (state target)
|
|
target-indax-grab
|
|
target-slide-down ;; associated process guessed by decompiler, old: (state target)
|
|
target-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-pilot-start ;; associated process guessed by decompiler, old: (state handle symbol symbol target)
|
|
target-walk ;; associated process guessed by decompiler, old: (state target)
|
|
target-turn-around ;; associated process guessed by decompiler, old: (state target)
|
|
target-stance-ambient ;; associated process guessed by decompiler, old: (state target)
|
|
target-slide-down-to-ground ;; associated process guessed by decompiler, old: (state target)
|
|
target-hit-ground ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-stance-look-around ;; associated process guessed by decompiler, old: (state target)
|
|
target-tube ;; associated process guessed by decompiler, old: (state target)
|
|
target-duck-stance ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-jump ;; associated process guessed by decompiler, old: (state float float surface target)
|
|
target-mech-carry-pickup ;; associated process guessed by decompiler, old: (state target)
|
|
target-jump-forward ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-high-jump ;; associated process guessed by decompiler, old: (state float float object target)
|
|
target-falling ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-attack-uppercut ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-running-attack ;; associated process guessed by decompiler, old: (state target)
|
|
target-flop ;; associated process guessed by decompiler, old: (state float float float target)
|
|
target-pilot-grab ;; associated process guessed by decompiler, old: (state target)
|
|
target-roll ;; associated process guessed by decompiler, old: (state target)
|
|
target-roll-flip ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-pole-flip-up ;; associated process guessed by decompiler, old: (state object object float target)
|
|
target-mech-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-grab ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-grab-ride
|
|
target-pole-flip-up-jump ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-board-turn-to ;; associated process guessed by decompiler, old: (state vector time-frame target)
|
|
target-pole-flip-forward ;; associated process guessed by decompiler, old: (state float float float target)
|
|
target-clone-anim ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-blast-recover
|
|
target-pole-flip-forward-jump ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-hide ;; associated process guessed by decompiler, old: (state target)
|
|
target-edge-grab ;; associated process guessed by decompiler, old: (state target)
|
|
target-edge-grab-jump ;; associated process guessed by decompiler, old: (state float float target)
|
|
target-edge-grab-off ;; associated process guessed by decompiler, old: (state target)
|
|
target-eco-powerup
|
|
target-mech-jump ;; associated process guessed by decompiler, old: (state float float surface target)
|
|
target-play-anim ;; associated process guessed by decompiler, old: (state string handle target)
|
|
target-launch ;; associated process guessed by decompiler, old: (state float symbol vector int target)
|
|
target-float ;; associated process guessed by decompiler, old: (state target)
|
|
target-powerjak-get-on
|
|
target-board-wall-kick ;; associated process guessed by decompiler, old: (state vector float target)
|
|
target-lightjak-swoop-again
|
|
target-lightjak-get-off
|
|
target-lightjak-swoop
|
|
target-lightjak-shield
|
|
target-lightjak-regen
|
|
target-invisible-get-on
|
|
target-flut-clone-anim
|
|
target-launch-dir
|
|
target-gun-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-gun-walk ;; associated process guessed by decompiler, old: (state target)
|
|
target-board-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-board-start ;; associated process guessed by decompiler, old: (state object target)
|
|
target-flut-air-attack-hit-ground
|
|
target-board-duck-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-indax-hang
|
|
target-board-jump ;; associated process guessed by decompiler, old: (state meters meters symbol target)
|
|
target-board-halfpipe ;; associated process guessed by decompiler, old: (state target)
|
|
target-board-clone-anim ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-pilot-clone-anim ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-board-falling ;; associated process guessed by decompiler, old: (state target)
|
|
target-board-jump-kick ;; associated process guessed by decompiler, old: (state target)
|
|
target-board-turn-around
|
|
target-board-flip ;; associated process guessed by decompiler, old: (state float float symbol target)
|
|
target-board-hold ;; associated process guessed by decompiler, old: (state float float symbol target)
|
|
target-board-tricky
|
|
target-board-trickx ;; associated process guessed by decompiler, old: (state float float symbol target)
|
|
target-board-hit-ground ;; associated process guessed by decompiler, old: (state target)
|
|
target-board-ride-edge ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-board-grenade ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-board-get-on ;; associated process guessed by decompiler, old: (state target)
|
|
target-board-get-off ;; associated process guessed by decompiler, old: (state object symbol target)
|
|
target-board-grab ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-mech-death ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-board-hit ;; associated process guessed by decompiler, old: (state vector attack-info target)
|
|
target-warp-out ;; associated process guessed by decompiler, old: (state vector vector target target)
|
|
target-warp-in ;; associated process guessed by decompiler, old: (state vector vector target target)
|
|
target-pilot-get-off ;; associated process guessed by decompiler, old: (state target)
|
|
target-pilot-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-pilot-impact ;; associated process guessed by decompiler, old: (state target)
|
|
target-pilot-hit ;; associated process guessed by decompiler, old: (state symbol attack-info target)
|
|
target-pilot-daxter-perch
|
|
target-pilot-get-on ;; associated process guessed by decompiler, old: (state target)
|
|
target-pilot-edge-grab ;; associated process guessed by decompiler, old: (state pilot-edge-grab-info target)
|
|
target-pilot-death ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-mech-get-up
|
|
target-mech-punch ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-get-off ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-carry-stance ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-walk ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-falling ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-mech-carry-drop ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-hit-ground ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-mech-hit ;; associated process guessed by decompiler, old: (state symbol attack-info target)
|
|
target-mech-carry-walk ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-carry-drag ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-carry-falling ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-carry-hit-ground ;; associated process guessed by decompiler, old: (state symbol target)
|
|
target-mech-carry-jump ;; associated process guessed by decompiler, old: (state float float symbol target)
|
|
target-mech-carry-throw ;; associated process guessed by decompiler, old: (state target)
|
|
target-mech-get-on ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-mech-shield
|
|
target-mech-clone-anim ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-ladder
|
|
target-flut-get-off-jump
|
|
target-flut-hit-ground
|
|
target-flut-walk
|
|
target-flut-get-off
|
|
target-flut-kanga-catch
|
|
target-flut-running-attack
|
|
target-flut-double-jump
|
|
target-flut-start ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-flut-stance
|
|
target-flut-falling
|
|
target-flut-jump
|
|
target-flut-air-attack
|
|
target-flut-hit
|
|
target-flut-get-on
|
|
target-flut-eject
|
|
target-flut-grab
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sidekick (process-drawable)
|
|
((control control-info :offset-assert 128) ;; guessed by decompiler
|
|
(anim-seed uint64 :offset-assert 208)
|
|
(shadow-in-movie? symbol :offset-assert 216) ;; guessed by decompiler
|
|
(special-anim-time uint64 :offset-assert 224) ;; time-frame
|
|
(special-anim-interp float :offset-assert 232)
|
|
(special-anim-frame float :offset-assert 236)
|
|
(offset transformq :inline :offset-assert 240)
|
|
(mirror (pointer process-drawable) :offset-assert 288) ;; guessed by decompiler
|
|
(ear UNKNOWN 2 :offset-assert 292)
|
|
(flap UNKNOWN 2 :offset-assert 300)
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x134
|
|
:flag-assert #x1400c00134
|
|
(:states
|
|
sidekick-clone ;; associated process guessed by decompiler, old: (state sidekick)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *target* object) ;; target
|
|
;; (define-extern *sidekick* object) ;; sidekick
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; capture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern gs-set-default-store-image function) ;; (function gs-store-image-packet int int gs-psm int int int int int)
|
|
;; (define-extern store-image function) ;; (function screen-shot-work int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-tables ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ocean-colors-city* object) ;; ocean-colors
|
|
;; (define-extern *ocean-near-indices-city* ocean-near-indices) ;; ocean-near-indices
|
|
;; (define-extern *ocean-trans-indices-city* ocean-trans-indices) ;; ocean-trans-indices
|
|
;; (define-extern *ocean-mid-indices-city* ocean-mid-indices) ;; ocean-mid-indices
|
|
;; (define-extern *ocean-mid-masks-city* ocean-mid-masks) ;; ocean-mid-masks
|
|
;; (define-extern *ocean-map-city* object) ;; ocean-map
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; car ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype h-car-base (hvehicle)
|
|
((rider-hand-joint-array UNKNOWN 2 :offset-assert 944)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x3b2
|
|
:flag-assert #xa2034003b2
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-car-a (h-car-base)
|
|
((steering-wheel-l joint-mod-rotate-local :inline :offset-assert 960)
|
|
(steering-wheel-r joint-mod-rotate-local :inline :offset-assert 992)
|
|
(fin-fl joint-mod-rotate-local :inline :offset-assert 1024)
|
|
(fin-fr joint-mod-rotate-local :inline :offset-assert 1056)
|
|
(fin-rl joint-mod-rotate-local :inline :offset-assert 1088)
|
|
(fin-rr joint-mod-rotate-local :inline :offset-assert 1120)
|
|
(rudder-l joint-mod-rotate-local :inline :offset-assert 1152)
|
|
(rudder-r joint-mod-rotate-local :inline :offset-assert 1184)
|
|
(rudder joint-mod-rotate-local :inline :offset-assert 1216)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x4e0
|
|
:flag-assert #xa2046004e0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-car-b (h-car-base)
|
|
((steering-wheel-l joint-mod-rotate-local :inline :offset-assert 960)
|
|
(steering-wheel-r joint-mod-rotate-local :inline :offset-assert 992)
|
|
(fin-fl joint-mod-rotate-local :inline :offset-assert 1024)
|
|
(fin-fr joint-mod-rotate-local :inline :offset-assert 1056)
|
|
(fin-rl joint-mod-rotate-local :inline :offset-assert 1088)
|
|
(fin-rr joint-mod-rotate-local :inline :offset-assert 1120)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x480
|
|
:flag-assert #xa204000480
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-car-c (h-car-base)
|
|
((steering-wheel joint-mod-rotate-local :inline :offset-assert 960)
|
|
(fin-fl joint-mod-rotate-local :inline :offset-assert 992)
|
|
(fin-fr joint-mod-rotate-local :inline :offset-assert 1024)
|
|
(fin-rl joint-mod-rotate-local :inline :offset-assert 1056)
|
|
(fin-rr joint-mod-rotate-local :inline :offset-assert 1088)
|
|
(fin2-rl joint-mod-rotate-local :inline :offset-assert 1120)
|
|
(fin2-rr joint-mod-rotate-local :inline :offset-assert 1152)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x4a0
|
|
:flag-assert #xa2042004a0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *h-car-explosion-info* vehicle-explosion-info)
|
|
;; (define-extern *h-car-a-constants* object)
|
|
;; (define-extern *h-car-b-constants* object)
|
|
;; (define-extern *h-car-c-constants* object)
|
|
;; (define-extern *h-hellcat-constants* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mhcityb-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *lmhcityb-tfrag-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; memory-usage-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype memory-usage-info (structure)
|
|
((name string :offset-assert 0) ;; guessed by decompiler
|
|
(count int32 :offset-assert 4)
|
|
(used int32 :offset-assert 8)
|
|
(total int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype memory-usage-block (basic)
|
|
((work-bsp basic :offset-assert 4)
|
|
(length int32 :offset-assert 8)
|
|
(data memory-usage-info 113 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x720
|
|
:flag-assert #xc00000720
|
|
(:methods
|
|
(memory-usage-block-method-9 () none) ;; 9 ;; (reset! (_type_) _type_ 9)
|
|
(memory-usage-block-method-10 () none) ;; 10 ;; (calculate-total (_type_) int 10)
|
|
(memory-usage-block-method-11 () none) ;; 11 ;; (print-mem-usage (_type_ level object) _type_ 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *mem-usage* object) ;; memory-usage-block
|
|
;; (define-extern *dma-mem-usage* object) ;; memory-usage-block
|
|
;; (define-extern *temp-mem-usage* object) ;; memory-usage-block
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blit-displays-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype blit-displays-work (structure)
|
|
((adgif-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(sprite-tmpl dma-gif-packet :inline :offset-assert 32)
|
|
(contrast-tmpl dma-gif-packet :inline :offset-assert 64)
|
|
(sprite-slow-tmpl dma-gif-packet :inline :offset-assert 96)
|
|
(draw-slow-time-tmpl dma-gif-packet :inline :offset-assert 128)
|
|
(line-tmpl dma-gif-packet :inline :offset-assert 160)
|
|
(scan-tmpl dma-gif-packet :inline :offset-assert 192)
|
|
(color vector4w :inline :offset-assert 224)
|
|
(line-color uint64 :offset-assert 240)
|
|
(scan-colors vector4w 15 :offset-assert 256) ;; guessed by decompiler
|
|
(zoom-blur-pos vector :inline :offset-assert 496)
|
|
(zoom-blur-count int32 :offset-assert 512)
|
|
(zoom-blur-texels int32 :offset-assert 516)
|
|
(zoom-blur-alpha-target float :offset-assert 520)
|
|
(zoom-blur-alpha-current float :offset-assert 524)
|
|
(zoom-blur-2d basic :offset-assert 528)
|
|
(menu-mode symbol :offset-assert 532) ;; guessed by decompiler
|
|
(screen-copied symbol :offset-assert 536) ;; guessed by decompiler
|
|
(vu1-enable-user-menu uint64 :offset-assert 544) ;; vu1-renderer-mask
|
|
(texture-enable-user-menu uint32 :offset-assert 552)
|
|
(count-down uint32 :offset-assert 556)
|
|
(horizontal-flip-flag symbol :offset-assert 560) ;; guessed by decompiler
|
|
(scan-alpha float :offset-assert 564)
|
|
(scanline uint32 :offset-assert 568)
|
|
(progress-interp float :offset-assert 572)
|
|
(progress-interp-dest float :offset-assert 576)
|
|
(progress-interp-speed float :offset-assert 580)
|
|
(slow-time float :offset-assert 584)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #x24c
|
|
:flag-assert #x1b0000024c
|
|
(:methods
|
|
(blit-displays-work-method-9 () none) ;; 9
|
|
(blit-displays-work-method-10 () none) ;; 10
|
|
(blit-displays-work-method-11 () none) ;; 11
|
|
(blit-displays-work-method-12 () none) ;; 12
|
|
(blit-displays-work-method-13 () none) ;; 13
|
|
(blit-displays-work-method-14 () none) ;; 14
|
|
(blit-displays-work-method-15 () none) ;; 15
|
|
(blit-displays-work-method-16 () none) ;; 16
|
|
(blit-displays-work-method-17 () none) ;; 17
|
|
(blit-displays-work-method-18 () none) ;; 18
|
|
(blit-displays-work-method-19 () none) ;; 19
|
|
(blit-displays-work-method-20 () none) ;; 20
|
|
(blit-displays-work-method-21 () none) ;; 21
|
|
(blit-displays-work-method-22 () none) ;; 22
|
|
(blit-displays-work-method-23 () none) ;; 23
|
|
(blit-displays-work-method-24 () none) ;; 24
|
|
(blit-displays-work-method-25 () none) ;; 25
|
|
(blit-displays-work-method-26 () none) ;; 26
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sky-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sky-color-hour (structure)
|
|
((snapshot1 int32 :offset-assert 0)
|
|
(snapshot2 int32 :offset-assert 4)
|
|
(morph-start float :offset-assert 8)
|
|
(morph-end float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sky-color-day (structure)
|
|
((hour sky-color-hour 24 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x180
|
|
:flag-assert #x900000180
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sky-sun-data (structure)
|
|
((data uint128 4 :offset-assert 0) ;; guessed by decompiler
|
|
(pos vector :inline :offset-assert 0)
|
|
(r-sun float :offset-assert 16)
|
|
(r-halo float :offset-assert 20)
|
|
(r-aurora float :offset-assert 24)
|
|
(c-sun-start rgba :offset-assert 32) ;; guessed by decompiler
|
|
(c-sun-end rgba :offset-assert 48) ;; guessed by decompiler
|
|
(c-halo-start rgba :offset-assert 36) ;; guessed by decompiler
|
|
(c-halo-end rgba :offset-assert 52) ;; guessed by decompiler
|
|
(c-aurora-start rgba :offset-assert 40) ;; guessed by decompiler
|
|
(c-aurora-end rgba :offset-assert 56) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sky-moon-data (structure)
|
|
((data uint128 2 :offset-assert 0) ;; guessed by decompiler
|
|
(pos vector :inline :offset-assert 0)
|
|
(scale vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sky-orbit (structure)
|
|
((high-noon float :offset-assert 0)
|
|
(tilt float :offset-assert 4)
|
|
(rise float :offset-assert 8)
|
|
(dist float :offset-assert 12)
|
|
(min-halo float :offset-assert 16)
|
|
(max-halo float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sky-upload-data (structure)
|
|
((data uint128 16 :offset-assert 0) ;; guessed by decompiler
|
|
(sun sky-sun-data 2 :offset-assert 0) ;; guessed by decompiler
|
|
(moon sky-moon-data :inline :offset-assert 128)
|
|
(day-star sky-moon-data :inline :offset-assert 192)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x100
|
|
:flag-assert #x900000100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sky-vertex (structure)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cloud-vertex (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(stq vector :inline :offset-assert 16)
|
|
(col vector :inline :offset-assert 32)
|
|
(nrm vector :inline :offset-assert 48)
|
|
(stq2 vector :inline :offset-assert 64)
|
|
(col2 vector :inline :offset-assert 80)
|
|
(nrm2 vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cloud-vert-array (structure)
|
|
((data cloud-vertex 100 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2bc0
|
|
:flag-assert #x900002bc0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype haze-vertex (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(nrm vector :inline :offset-assert 16)
|
|
(col vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype haze-vert-array (structure)
|
|
((data haze-vertex 36 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6c0
|
|
:flag-assert #x9000006c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cloud-lights (structure)
|
|
((sun0-normal vector :inline :offset-assert 0)
|
|
(sun1-normal vector :inline :offset-assert 16)
|
|
(moon-normal vector :inline :offset-assert 32)
|
|
(ambi-color vector :inline :offset-assert 48)
|
|
(ambi-color-lower vector :inline :offset-assert 64)
|
|
(sun0-color vector :inline :offset-assert 80)
|
|
(sun1-color vector :inline :offset-assert 96)
|
|
(moon-color vector :inline :offset-assert 112)
|
|
(sun0-color-lower vector :inline :offset-assert 128)
|
|
(sun0-scale float :offset-assert 144)
|
|
(sun1-scale float :offset-assert 148)
|
|
(moon-scale float :offset-assert 152)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x9c
|
|
:flag-assert #x90000009c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype haze-lights (structure)
|
|
((sun0-normal vector :inline :offset-assert 0)
|
|
(sun1-normal vector :inline :offset-assert 16)
|
|
(moon-normal vector :inline :offset-assert 32)
|
|
(ambi-color vector :inline :offset-assert 48)
|
|
(sun0-color vector :inline :offset-assert 64)
|
|
(sun1-color vector :inline :offset-assert 80)
|
|
(moon-color vector :inline :offset-assert 96)
|
|
(sun0-scale float :offset-assert 112)
|
|
(sun1-scale float :offset-assert 116)
|
|
(moon-scale float :offset-assert 120)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x7c
|
|
:flag-assert #x90000007c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sky-work (structure)
|
|
((adgif-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(draw-tmpl dma-gif-packet :inline :offset-assert 32)
|
|
(draw-tmpl2 dma-gif-packet :inline :offset-assert 64)
|
|
(fog-tmpl dma-gif-packet :inline :offset-assert 96)
|
|
(blend-tmpl dma-gif-packet :inline :offset-assert 128)
|
|
(sprite-tmpl dma-gif-packet :inline :offset-assert 160)
|
|
(sprite-tmpl2 dma-gif-packet :inline :offset-assert 192)
|
|
(sun-coords vector 2 :offset-assert 224) ;; guessed by decompiler
|
|
(green-coords vector 2 :offset-assert 256) ;; guessed by decompiler
|
|
(moon0-coords vector 2 :offset-assert 288) ;; guessed by decompiler
|
|
(moon1-coords vector 2 :offset-assert 320) ;; guessed by decompiler
|
|
(moon2-coords vector 2 :offset-assert 352) ;; guessed by decompiler
|
|
(day-star-coords UNKNOWN 2 :offset-assert 384)
|
|
(star-coords vector 2 :offset-assert 416) ;; guessed by decompiler
|
|
(sun-colors vector4w 2 :offset-assert 448) ;; guessed by decompiler
|
|
(green-colors vector4w 2 :offset-assert 480) ;; guessed by decompiler
|
|
(moon-colors vector4w 3 :offset-assert 512) ;; guessed by decompiler
|
|
(day-star-colors UNKNOWN 3 :offset-assert 560)
|
|
(star-colors vector4w 16 :offset-assert 608) ;; guessed by decompiler
|
|
(st-coords vector 2 :offset-assert 864) ;; guessed by decompiler
|
|
(random vector4w 8 :offset-assert 896) ;; guessed by decompiler
|
|
(giftag-base dma-gif :inline :offset-assert 1024)
|
|
(giftag-haze dma-gif :inline :offset-assert 1040)
|
|
(giftag-roof dma-gif :inline :offset-assert 1056)
|
|
(giftag-ocean dma-gif :inline :offset-assert 1072)
|
|
(fog vector :inline :offset-assert 1088)
|
|
(sky float 8 :offset-assert 1104) ;; guessed by decompiler
|
|
(time float :offset-assert 1136)
|
|
(off-s uint16 :offset-assert 1140)
|
|
(off-t uint16 :offset-assert 1142)
|
|
(orbit sky-orbit 3 :offset-assert 1144) ;; guessed by decompiler
|
|
(upload-data sky-upload-data :inline :offset-assert 1248)
|
|
(ambi-color vector :inline :offset-assert 1504) ;; vector4w :inline
|
|
(ambi-color-lower vector :inline :offset-assert 1520) ;; vector4w :inline
|
|
(sun0-color vector :inline :offset-assert 1536) ;; vector4w :inline
|
|
(sun1-color vector :inline :offset-assert 1552) ;; vector4w :inline
|
|
(moon-color vector :inline :offset-assert 1568) ;; vector4w :inline
|
|
(sun0-color-lower vector :inline :offset-assert 1584) ;; vector4w :inline
|
|
(cam-mat matrix :inline :offset-assert 1600)
|
|
(star-mat matrix :inline :offset-assert 1664)
|
|
(vec0 vector4w :inline :offset-assert 1728)
|
|
(vec1 vector4w :inline :offset-assert 1744)
|
|
(cloud-lights cloud-lights :inline :offset-assert 1760)
|
|
(haze-lights haze-lights :inline :offset-assert 1920)
|
|
(buf dma-buffer :offset-assert 2044) ;; guessed by decompiler
|
|
(draw-vortex basic :offset-assert 2048)
|
|
(day-star-scale float :offset-assert 2052)
|
|
(stars vector 512 :offset-assert 2064) ;; guessed by decompiler
|
|
(disable-day-star basic :offset-assert 10256)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x2814
|
|
:flag-assert #x2700002814
|
|
(:methods
|
|
(sky-work-method-9 () none) ;; 9 ;; (init-sun-data! (_type_ int float float float) none 9)
|
|
(sky-work-method-10 () none) ;; 10 ;; (init-orbit-settings! (_type_ int float float float float float float) none 10)
|
|
(sky-work-method-11 () none) ;; 11 ;; (update-colors-for-time (_type_ float) none 11)
|
|
(sky-work-method-12 () none) ;; 12 ;; (update-time-and-speed (_type_ float float) none 12)
|
|
(sky-work-method-13 () none) ;; 13 ;; (draw (_type_) none 13)
|
|
(sky-work-method-14 () none) ;; 14 ;; (update-matrix (_type_ matrix) none 14)
|
|
(sky-work-method-15 () none) ;; 15 ;; (update-template-colors (_type_) none 15)
|
|
(sky-work-method-16 () none) ;; 16 ;; (init-regs-for-large-polygon-draw (_type_) none 16)
|
|
(sky-work-method-17 () none) ;; 17 ;; (init-regs-for-sky-asm (_type_) none 17)
|
|
(sky-work-method-18 () none) ;; 18 ;; (cloud-vtx-light-update (_type_ vector vector cloud-lights vector vector) none 18)
|
|
(sky-work-method-19 () none) ;; 19 ;; (cloud-vtx-tex-update (_type_ vector vector vector cloud-lights) none 19)
|
|
(sky-work-method-20 () none) ;; 20 ;; (adjust-cloud-lighting (_type_) none 20)
|
|
(sky-work-method-21 () none) ;; 21 ;; (cloud-vtx1-to-sky (_type_ sky-vertex cloud-vertex) none 21)
|
|
(sky-work-method-22 () none) ;; 22 ;; (cloud-vtx2-to-sky (_type_ sky-vertex cloud-vertex) none 22)
|
|
(sky-work-method-23 () none) ;; 23 ;; (draw-clouds (_type_ dma-buffer) none 23)
|
|
(sky-work-method-24 () none) ;; 24 ;; (apply-haze-light (_type_ vector vector haze-lights) none 24)
|
|
(sky-work-method-25 () none) ;; 25 ;; (adjust-haze-lighting (_type_) none 25)
|
|
(sky-work-method-26 () none) ;; 26 ;; (haze-vtx-to-sky (_type_ sky-vertex sky-vertex haze-vertex) none 26)
|
|
(sky-work-method-27 () none) ;; 27 ;; (draw-haze (_type_ dma-buffer) none 27)
|
|
(sky-work-method-28 () none) ;; 28 ;; (sun-dma (_type_ dma-buffer) none 28)
|
|
(sky-work-method-29 () none) ;; 29 ;; (green-sun-dma (_type_ dma-buffer) none 29)
|
|
(sky-work-method-30 () none) ;; 30 ;; (moon-dma (_type_ dma-buffer) none 30)
|
|
(sky-work-method-31 () none) ;; 31 ;; (setup-stars (_type_ matrix sky-upload-data) none 31)
|
|
(sky-work-method-32 () none) ;; 32 ;; (stars-transform-asm (_type_) none 32)
|
|
(sky-work-method-33 () none) ;; 33 ;; (stars-dma (_type_ dma-buffer) none 33)
|
|
(sky-work-method-34 () none) ;; 34 ;; (draw-roof (_type_ dma-buffer) none 34)
|
|
(sky-work-method-35 () none) ;; 35 ;; (draw-base (_type_ dma-buffer) none 35)
|
|
(sky-work-method-36 () none) ;; 36 ;; (draw-fog (_type_ dma-buffer) none 36)
|
|
(sky-work-method-37 () none) ;; 37
|
|
(sky-work-method-38 () none) ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-darkjak ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype darkjak-ball (projectile)
|
|
((impact? basic :offset-assert 512)
|
|
(fire-point vector :inline :offset-assert 528)
|
|
(explode-sound uint32 :offset-assert 544)
|
|
(bolts basic :offset-assert 548)
|
|
(ball-pos UNKNOWN 2 :offset-assert 560)
|
|
(trail basic :offset-assert 592)
|
|
(ball1 basic :offset-assert 596)
|
|
(last-ground-height float :offset-assert 600)
|
|
(fire-sound uint32 :offset-assert 604)
|
|
)
|
|
:method-count-assert 42
|
|
:size-assert #x260
|
|
:flag-assert #x2a01e00260
|
|
(:methods
|
|
(darkjak-ball-method-41 () none) ;; 41
|
|
)
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern darkjak-ball-slide-reaction function)
|
|
;; (define-extern darkjak-ball-move function)
|
|
;; (define-extern *darkjak-ball-lightning* object)
|
|
;; (define-extern *darkjak-ball-lightning-colors* array)
|
|
;; (define-extern sparticle-track-hadouken function)
|
|
;; (define-extern target-darkjak-setup function) ;; (function symbol none :behavior target)
|
|
;; (define-extern want-to-darkjak? function) ;; (function symbol :behavior target)
|
|
;; (define-extern *darkjak-trans-mods* object) ;; surface
|
|
;; (define-extern target-darkjak-end-mode function) ;; (function none :behavior target)
|
|
;; (define-extern target-darkjak-process function) ;; (function none :behavior target)
|
|
;; (define-extern target-darkjak-bomb-collide function) ;; (function float float none :behavior target)
|
|
;; (define-extern target-bomb1-fire-shot function) ;; (function (pointer handle) int int int none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mine-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype leggings (process-drawable)
|
|
((alt-actor basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *range-explo-door-dust-color* curve-color-fast)
|
|
;; (define-extern *range-explo-door-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-explo-door-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-explo-door-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-explo-door-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-explo-door-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-explo-door-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-bomb-door-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-explo-door-color* curve-color-fast)
|
|
;; (define-extern *range-explo-door-alpha* curve2d-fast)
|
|
;; (define-extern *range-explo-door-scale-x* curve2d-fast)
|
|
;; (define-extern *range-explo-door-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-explo-door-alpha* curve2d-fast)
|
|
;; (define-extern *curve-explo-door-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-explo-door-scale-y* curve2d-fast)
|
|
;; (define-extern *part-bomb-door-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-tie-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype generic-tie-instance (structure)
|
|
((matrix-tag dma-packet :inline :offset-assert 0)
|
|
(matrix-data vector 6 :offset-assert 16) ;; guessed by decompiler
|
|
(index-tag dma-packet :inline :offset-assert 112)
|
|
(indices uint8 224 :offset-assert 128) ;; guessed by decompiler
|
|
(end-tag dma-packet :inline :offset-assert 352)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x170
|
|
:flag-assert #x900000170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-input (structure)
|
|
((palette-tag dma-packet :inline :offset-assert 0)
|
|
(palette rgba 128 :offset-assert 16) ;; guessed by decompiler
|
|
(model-tag dma-packet :inline :offset-assert 528)
|
|
(model vector 146 :offset-assert 544) ;; guessed by decompiler
|
|
(matrix-tag dma-packet :inline :offset-assert 2880)
|
|
(matrix-data vector 6 :offset-assert 2896) ;; guessed by decompiler
|
|
(index-tag dma-packet :inline :offset-assert 2992)
|
|
(indices uint8 224 :offset-assert 3008) ;; guessed by decompiler
|
|
(end-tag dma-packet :inline :offset-assert 3232)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xcb0
|
|
:flag-assert #x900000cb0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-run-control (structure)
|
|
((skip-bp2 uint8 :offset-assert 0)
|
|
(skip-ips uint8 :offset-assert 1)
|
|
(gifbuf-skip uint8 :offset-assert 2)
|
|
(strips uint8 :offset-assert 3)
|
|
(target-bp1 uint8 :offset-assert 4)
|
|
(target-bp2 uint8 :offset-assert 5)
|
|
(target-ip1 uint8 :offset-assert 6)
|
|
(target-ip2 uint8 :offset-assert 7)
|
|
(target-bps uint8 :offset-assert 8)
|
|
(target-ips uint8 :offset-assert 9)
|
|
(is-generic uint8 :offset-assert 10)
|
|
(reserved uint8 :offset-assert 11)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-base-point (structure)
|
|
((data uint16 8 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
(x int16 :offset-assert 0)
|
|
(y int16 :offset-assert 2)
|
|
(z int16 :offset-assert 4)
|
|
(d0 int16 :offset-assert 6)
|
|
(vtx uint64 :offset-assert 0)
|
|
(u int16 :offset-assert 8)
|
|
(v int16 :offset-assert 10)
|
|
(tex uint32 :offset-assert 8)
|
|
(w int16 :offset-assert 12)
|
|
(d1 int16 :offset-assert 14)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-bps (structure)
|
|
((bp generic-tie-base-point 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-interp-point (structure)
|
|
((data uint16 12 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
(x int16 :offset-assert 0)
|
|
(y int16 :offset-assert 2)
|
|
(z int16 :offset-assert 4)
|
|
(d0 int16 :offset-assert 6)
|
|
(vtx0 uint64 :offset-assert 0)
|
|
(dx int16 :offset-assert 8)
|
|
(dy int16 :offset-assert 10)
|
|
(dz int16 :offset-assert 12)
|
|
(unused int16 :offset-assert 14)
|
|
(vtx1 uint64 :offset-assert 8)
|
|
(u int16 :offset-assert 16)
|
|
(v int16 :offset-assert 18)
|
|
(tex uint32 :offset-assert 16)
|
|
(w int16 :offset-assert 20)
|
|
(d1 int16 :offset-assert 22)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-ips (structure)
|
|
((ip generic-tie-interp-point 2 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-header (structure)
|
|
((effect uint8 :offset-assert 0)
|
|
(interp-table-size uint8 :offset-assert 1)
|
|
(num-bps uint8 :offset-assert 2)
|
|
(num-ips uint8 :offset-assert 3)
|
|
(tint-color uint32 :offset-assert 4)
|
|
(index-table-offset uint16 :offset-assert 8)
|
|
(kick-table-offset uint16 :offset-assert 10)
|
|
(normal-table-offset uint16 :offset-assert 12)
|
|
(interp-table-offset uint16 :offset-assert 14)
|
|
(gsf-header gsf-header :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-matrix (structure)
|
|
((matrix matrix :inline :offset-assert 0)
|
|
(morph vector :inline :offset-assert 64)
|
|
(fog qword :inline :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-normal (structure)
|
|
((x int8 :offset-assert 0)
|
|
(y int8 :offset-assert 1)
|
|
(z int8 :offset-assert 2)
|
|
(dummy int8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-control (structure)
|
|
((ptr-palette uint32 :offset-assert 0)
|
|
(ptr-shaders uint32 :offset-assert 4)
|
|
(ptr-runctrl generic-tie-run-control :offset-assert 8)
|
|
(ptr-verts uint32 :offset-assert 12)
|
|
(ptr-generic generic-tie-header :offset-assert 16)
|
|
(ptr-dps uint32 :offset-assert 20)
|
|
(ptr-kicks uint32 :offset-assert 24)
|
|
(ptr-normals uint32 :offset-assert 28)
|
|
(ptr-interp uint32 :offset-assert 32)
|
|
(ptr-mtxs generic-tie-matrix :offset-assert 36)
|
|
(ptr-cinds uint32 :offset-assert 40)
|
|
(next-instance uint32 :offset-assert 44)
|
|
(next-model uint32 :offset-assert 48)
|
|
(next-is-model uint32 :offset-assert 52)
|
|
(tie-type uint32 :offset-assert 56)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-stats (structure)
|
|
((num-bps uint32 :offset-assert 0)
|
|
(num-ips uint32 :offset-assert 4)
|
|
(num-dps uint32 :offset-assert 8)
|
|
(num-shaders uint32 :offset-assert 12)
|
|
(num-models uint32 :offset-assert 16)
|
|
(num-instances uint32 :offset-assert 20)
|
|
(num-waits uint32 :offset-assert 24)
|
|
(num-qwc uint32 :offset-assert 28)
|
|
(max-qwc uint32 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-calls (structure)
|
|
((generic-prepare-dma-double basic :offset-assert 0)
|
|
(generic-envmap-dproc basic :offset-assert 4)
|
|
(generic-interp-dproc basic :offset-assert 8)
|
|
(generic-no-light-dproc basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-shadow (structure)
|
|
((out-buf gsf-buffer :offset-assert 0)
|
|
(cur-buf uint32 :offset-assert 4)
|
|
(tie-type int32 :offset-assert 8)
|
|
(ptr-inst uint32 :offset-assert 12)
|
|
(ptr-buf uint32 :offset-assert 16)
|
|
(inst-xor int32 :offset-assert 20)
|
|
(end-of-chain uint32 :offset-assert 24)
|
|
(write-limit uint32 :offset-assert 28)
|
|
(calls generic-tie-calls :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tie-work (structure)
|
|
((control generic-tie-control :inline :offset-assert 0)
|
|
(interp-job generic-interp-job :inline :offset-assert 60)
|
|
(shadow generic-tie-shadow :inline :offset-assert 76)
|
|
(input-a generic-tie-input :inline :offset-assert 128)
|
|
(input-b generic-tie-input :inline :offset-assert 3376)
|
|
(inst-buf generic-tie-instance :inline :offset-assert 6624)
|
|
(palette-buf rgba 128 :offset-assert 6992) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1d50
|
|
:flag-assert #x900001d50
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ocean-corner (structure)
|
|
((bsphere sphere :inline :offset-assert 0)
|
|
(start-corner vector :inline :offset-assert 16)
|
|
(y-scales vector :inline :offset-assert 32)
|
|
(alphas vector :inline :offset-assert 48)
|
|
(colors uint32 4 :offset-assert 64) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-wave-info (structure)
|
|
((frequency float :offset-assert 0)
|
|
(amplitude float :offset-assert 4)
|
|
(wave-speed float :offset-assert 8)
|
|
(angle float :offset-assert 12)
|
|
(kx float :offset-assert 16)
|
|
(ky float :offset-assert 20)
|
|
(w float :offset-assert 24)
|
|
(flags int32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-vertex (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(stq vector :inline :offset-assert 16)
|
|
(col vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-spheres (structure)
|
|
((spheres sphere 36 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x240
|
|
:flag-assert #x900000240
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-colors (structure)
|
|
((colors rgba 2548 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x27d0
|
|
:flag-assert #x9000027d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-colors-float (structure)
|
|
((colors vector 2548 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x9f40
|
|
:flag-assert #x900009f40
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-mid-mask (structure)
|
|
((mask uint8 8 :offset-assert 0) ;; guessed by decompiler
|
|
(dword uint64 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-mid-indices (basic)
|
|
((data uint16 36 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-mid-masks (basic)
|
|
((data (inline-array ocean-mid-mask) :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-trans-mask (structure)
|
|
((mask uint8 4 :offset-assert 0) ;; guessed by decompiler
|
|
(word int32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-trans-index (structure)
|
|
((parent int16 :offset-assert 0)
|
|
(child int16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-trans-indices (basic)
|
|
((data ocean-trans-index 2304 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2404
|
|
:flag-assert #x900002404
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-near-index (structure)
|
|
((data uint16 16 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-near-indices (basic)
|
|
((data (inline-array ocean-near-index) :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-near-colors (structure)
|
|
((color0 vector :inline :offset-assert 0)
|
|
(color1 vector :inline :offset-assert 16)
|
|
(color2 vector :inline :offset-assert 32)
|
|
(color3 vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-trans-strip (structure)
|
|
((verts uint128 10 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa0
|
|
:flag-assert #x9000000a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-trans-strip-array (structure)
|
|
((data ocean-trans-strip 4 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x280
|
|
:flag-assert #x900000280
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-wave-data (structure)
|
|
((data uint8 1024 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x400
|
|
:flag-assert #x900000400
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-wave-frames (structure)
|
|
((frame ocean-wave-data 64 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x0
|
|
:heap-base #x1
|
|
:flag-assert #x900010000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-texture-constants (structure)
|
|
((giftag qword :inline :offset-assert 0) ;; gs-gif-tag :inline
|
|
(buffers vector4w :inline :offset-assert 16)
|
|
(dests vector4w :inline :offset-assert 32)
|
|
(start vector :inline :offset-assert 48)
|
|
(offsets vector :inline :offset-assert 64)
|
|
(constants vector :inline :offset-assert 80)
|
|
(cam-nrm vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-mid-vertex (structure)
|
|
((stq vector :inline :offset-assert 0)
|
|
(col vector :inline :offset-assert 16)
|
|
(pos vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-mid-constants (structure)
|
|
((hmge-scale vector :inline :offset-assert 0)
|
|
(inv-hmge-scale vector :inline :offset-assert 16)
|
|
(hvdf-offset vector :inline :offset-assert 32)
|
|
(fog vector :inline :offset-assert 48)
|
|
(constants vector :inline :offset-assert 64)
|
|
(constants2 vector :inline :offset-assert 80)
|
|
(drw-fan qword :inline :offset-assert 96) ;; gs-gif-tag :inline
|
|
(env-fan qword :inline :offset-assert 112) ;; gs-gif-tag :inline
|
|
(drw-adgif qword :inline :offset-assert 128) ;; gs-gif-tag :inline
|
|
(drw-texture adgif-shader :inline :offset-assert 144)
|
|
(drw-strip-0 qword :inline :offset-assert 224) ;; gs-gif-tag :inline
|
|
(drw-strip-1 qword :inline :offset-assert 240) ;; gs-gif-tag :inline
|
|
(env-adgif qword :inline :offset-assert 256) ;; gs-gif-tag :inline
|
|
(env-texture adgif-shader :inline :offset-assert 272)
|
|
(env-strip qword :inline :offset-assert 352) ;; gs-gif-tag :inline
|
|
(env-color vector :inline :offset-assert 368)
|
|
(index-table vector4w 8 :offset-assert 384) ;; guessed by decompiler
|
|
(pos0 vector :inline :offset-assert 512)
|
|
(pos1 vector :inline :offset-assert 528)
|
|
(pos2 vector :inline :offset-assert 544)
|
|
(pos3 vector :inline :offset-assert 560)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x240
|
|
:flag-assert #x900000240
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-mid-upload (structure)
|
|
((rot matrix :inline :offset-assert 0)
|
|
(matrix matrix :inline :offset-assert 64)
|
|
(colors uint128 108 :offset-assert 128) ;; guessed by decompiler
|
|
(masks uint128 2 :offset-assert 1856) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x760
|
|
:flag-assert #x900000760
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-mid-upload2 (structure)
|
|
((rot matrix :inline :offset-assert 0)
|
|
(matrix matrix :inline :offset-assert 64)
|
|
(count vector4w :inline :offset-assert 128)
|
|
(tex0 vector :inline :offset-assert 144)
|
|
(tex1 vector :inline :offset-assert 160)
|
|
(tex2 vector :inline :offset-assert 176)
|
|
(tex3 vector :inline :offset-assert 192)
|
|
(clr0 vector :inline :offset-assert 208)
|
|
(clr1 vector :inline :offset-assert 224)
|
|
(clr2 vector :inline :offset-assert 240)
|
|
(clr3 vector :inline :offset-assert 256)
|
|
(verts uint128 18 :offset-assert 272) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x230
|
|
:flag-assert #x900000230
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-mid-work (structure)
|
|
((env0 vector :inline :offset-assert 0)
|
|
(env1 vector :inline :offset-assert 16)
|
|
(env2 vector :inline :offset-assert 32)
|
|
(hmg0 vector :inline :offset-assert 48)
|
|
(hmg1 vector :inline :offset-assert 64)
|
|
(hmg2 vector :inline :offset-assert 80)
|
|
(indices uint128 16 :offset-assert 96) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x160
|
|
:flag-assert #x900000160
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-near-constants (structure)
|
|
((hmge-scale vector :inline :offset-assert 0)
|
|
(inv-hmge-scale vector :inline :offset-assert 16)
|
|
(hvdf-offset vector :inline :offset-assert 32)
|
|
(fog vector :inline :offset-assert 48)
|
|
(constants vector :inline :offset-assert 64)
|
|
(constants2 vector :inline :offset-assert 80)
|
|
(constants3 vector :inline :offset-assert 96)
|
|
(constants4 vector :inline :offset-assert 112)
|
|
(constants5 vector :inline :offset-assert 128)
|
|
(drw-fan qword :inline :offset-assert 144) ;; gs-gif-tag :inline
|
|
(drw2-fan qword :inline :offset-assert 160) ;; gs-gif-tag :inline
|
|
(env-fan qword :inline :offset-assert 176) ;; gs-gif-tag :inline
|
|
(drw-adgif qword :inline :offset-assert 192) ;; gs-gif-tag :inline
|
|
(drw-texture adgif-shader :inline :offset-assert 208)
|
|
(drw-strip qword :inline :offset-assert 288) ;; gs-gif-tag :inline
|
|
(env-adgif qword :inline :offset-assert 304) ;; gs-gif-tag :inline
|
|
(env-texture adgif-shader :inline :offset-assert 320)
|
|
(env-strip qword :inline :offset-assert 400) ;; gs-gif-tag :inline
|
|
(env-color vector :inline :offset-assert 416)
|
|
(drw2-adgif qword :inline :offset-assert 432) ;; gs-gif-tag :inline
|
|
(drw2-tex0 qword :inline :offset-assert 448)
|
|
(drw2-frame qword :inline :offset-assert 464)
|
|
(drw2-strip qword :inline :offset-assert 480) ;; gs-gif-tag :inline
|
|
(drw3-adgif qword :inline :offset-assert 496) ;; gs-gif-tag :inline
|
|
(drw3-frame qword :inline :offset-assert 512) ;; gs-adcmd :inline
|
|
(index-table vector4w 4 :offset-assert 528) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x250
|
|
:flag-assert #x900000250
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-near-upload (structure)
|
|
((rot matrix :inline :offset-assert 0)
|
|
(matrix matrix :inline :offset-assert 64)
|
|
(masks uint128 2 :offset-assert 128) ;; guessed by decompiler
|
|
(start-height vector4w :inline :offset-assert 160)
|
|
(start-st vector :inline :offset-assert 176)
|
|
(near-colors ocean-near-colors :inline :offset-assert 192)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x100
|
|
:flag-assert #x900000100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-near-vertex (structure)
|
|
((stq vector :inline :offset-assert 0)
|
|
(clr vector :inline :offset-assert 16)
|
|
(pos vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-near-work (structure)
|
|
((verts-ptr vector :inline :offset-assert 0)
|
|
(indices uint128 16 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x110
|
|
:flag-assert #x900000110
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-height-array (structure)
|
|
((data float 1024 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1000
|
|
:flag-assert #x900001000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-vert-array (structure)
|
|
((data vector 2048 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8000
|
|
:flag-assert #x900008000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean-map (structure)
|
|
((start-corner vector :inline :offset-assert 0)
|
|
(far-color vector :inline :offset-assert 16)
|
|
(ocean-colors ocean-colors :offset-assert 32)
|
|
(ocean-mid-indices ocean-mid-indices :offset-assert 36) ;; guessed by decompiler
|
|
(ocean-trans-indices ocean-trans-indices :offset-assert 40) ;; guessed by decompiler
|
|
(ocean-near-indices ocean-near-indices :offset-assert 44) ;; guessed by decompiler
|
|
(ocean-mid-masks ocean-mid-masks :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x34
|
|
:flag-assert #xb00000034
|
|
(:methods
|
|
(ocean-map-method-9 () none) ;; 9 ;; (set-height! (_type_ float) none 9)
|
|
(ocean-map-method-10 () none) ;; 10 ;; (get-base-height (_type_) float 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ocean (ocean-map)
|
|
((off symbol :offset-assert 52) ;; guessed by decompiler
|
|
(near-off symbol :offset-assert 56) ;; guessed by decompiler
|
|
(mid-off symbol :offset-assert 60) ;; guessed by decompiler
|
|
(far-on symbol :offset-assert 64) ;; guessed by decompiler
|
|
(all-on basic :offset-assert 68)
|
|
(ocean-facing uint32 :offset-assert 72)
|
|
(heights ocean-height-array :offset-assert 76)
|
|
(heights2 ocean-height-array :offset-assert 80)
|
|
(verts ocean-vert-array :offset-assert 84)
|
|
(ocean-near-translucent? symbol :offset-assert 88) ;; guessed by decompiler
|
|
(deltas vector :inline :offset-assert 96)
|
|
(map-min vector :inline :offset-assert 112)
|
|
(map-max vector :inline :offset-assert 128)
|
|
(interp vector :inline :offset-assert 144)
|
|
(corner-array ocean-corner 25 :offset-assert 160) ;; guessed by decompiler
|
|
(corner-count int32 :offset-assert 2160)
|
|
(temp-vecs vector 4 :offset-assert 2176) ;; guessed by decompiler
|
|
(mid-mask-ptrs pointer 36 :offset-assert 2240) ;; guessed by decompiler
|
|
(mid-camera-masks uint64 36 :offset-assert 2384) ;; guessed by decompiler
|
|
(trans-mask-ptrs pointer 64 :offset-assert 2672) ;; guessed by decompiler
|
|
(trans-camera-masks ocean-trans-mask 16 :offset-assert 2928) ;; guessed by decompiler
|
|
(trans-temp-masks uint32 16 :offset-assert 2992) ;; guessed by decompiler
|
|
(sprite-tmpl dma-gif-packet :inline :offset-assert 3056)
|
|
(sprite-tmpl2 dma-gif-packet :inline :offset-assert 3088)
|
|
(sprite-tmpl3 dma-gif-packet :inline :offset-assert 3120)
|
|
(adgif-tmpl dma-gif-packet :inline :offset-assert 3152)
|
|
(line-tmpl dma-gif-packet :inline :offset-assert 3184)
|
|
(sun-tmpl dma-gif-packet :inline :offset-assert 3216)
|
|
(erase-tmpl dma-gif-packet :inline :offset-assert 3248)
|
|
(haze-tmpl dma-gif-packet :inline :offset-assert 3280)
|
|
(cloud-tmpl dma-gif-packet :inline :offset-assert 3312)
|
|
(clut-tmpl dma-gif-packet :inline :offset-assert 3344)
|
|
(cloud-lights cloud-lights :inline :offset-assert 3376)
|
|
(haze-lights haze-lights :inline :offset-assert 3536)
|
|
(constant vector :inline :offset-assert 3664)
|
|
(sky-color vector :inline :offset-assert 3680)
|
|
(haze-verts vector4w 32 :offset-assert 3696) ;; guessed by decompiler
|
|
(cloud-verts vector4w 36 :offset-assert 4208) ;; guessed by decompiler
|
|
(cloud-nrms vector 36 :offset-assert 4784) ;; guessed by decompiler
|
|
(cloud-col0 vector 36 :offset-assert 5360) ;; guessed by decompiler
|
|
(cloud-col1 vector 36 :offset-assert 5936) ;; guessed by decompiler
|
|
(cloud-st0 vector 36 :offset-assert 6512) ;; guessed by decompiler
|
|
(cloud-st1 vector 36 :offset-assert 7088) ;; guessed by decompiler
|
|
(color80808080 vector4w :inline :offset-assert 7664)
|
|
(color80808040 vector4w :inline :offset-assert 7680)
|
|
(color80808000 vector4w :inline :offset-assert 7696)
|
|
(st0000 vector :inline :offset-assert 7712)
|
|
(st0505 vector :inline :offset-assert 7728)
|
|
(st1010 vector :inline :offset-assert 7744)
|
|
(uv00 vector4w :inline :offset-assert 7760)
|
|
(uv44 vector4w :inline :offset-assert 7776)
|
|
(uv88 vector4w :inline :offset-assert 7792)
|
|
(uv1010 vector4w :inline :offset-assert 7808)
|
|
(uv2020 vector4w :inline :offset-assert 7824)
|
|
(uv4040 vector4w :inline :offset-assert 7840)
|
|
(uv8080 vector4w :inline :offset-assert 7856)
|
|
(xy00 vector4w :inline :offset-assert 7872)
|
|
(xy88 vector4w :inline :offset-assert 7888)
|
|
(xy1010 vector4w :inline :offset-assert 7904)
|
|
(xy2020 vector4w :inline :offset-assert 7920)
|
|
(xy4040 vector4w :inline :offset-assert 7936)
|
|
(xy8080 vector4w :inline :offset-assert 7952)
|
|
(cloud-alpha uint8 36 :offset-assert 7968) ;; guessed by decompiler
|
|
(near-mask-indices uint16 16 :offset-assert 8004) ;; guessed by decompiler
|
|
(mid-minx uint8 :offset-assert 8036)
|
|
(mid-maxx uint8 :offset-assert 8037)
|
|
(mid-minz uint8 :offset-assert 8038)
|
|
(mid-maxz uint8 :offset-assert 8039)
|
|
(near-minx uint8 :offset-assert 8040)
|
|
(near-maxx uint8 :offset-assert 8041)
|
|
(near-minz uint8 :offset-assert 8042)
|
|
(near-maxz uint8 :offset-assert 8043)
|
|
(temp-minx uint8 :offset-assert 8044)
|
|
(temp-maxx uint8 :offset-assert 8045)
|
|
(temp-minz uint8 :offset-assert 8046)
|
|
(temp-maxz uint8 :offset-assert 8047)
|
|
(tex1 uint64 :offset-assert 8048) ;; gs-tex1
|
|
(tex1-near uint64 :offset-assert 8056) ;; gs-tex1
|
|
(corner00 float :offset-assert 8064)
|
|
(corner01 float :offset-assert 8068)
|
|
(corner10 float :offset-assert 8072)
|
|
(corner11 float :offset-assert 8076)
|
|
(frame-num float :offset-assert 8080)
|
|
(frame-speed float :offset-assert 8084)
|
|
(frame-num2 float :offset-assert 8088)
|
|
(frame-speed2 float :offset-assert 8092)
|
|
(cloud-interp float :offset-assert 3676)
|
|
(scales vector :inline :offset-assert 8096)
|
|
(mask-hi vector4w :inline :offset-assert 8112)
|
|
(mask-lo vector4w :inline :offset-assert 8128)
|
|
(lights vu-lights :inline :offset-assert 8144)
|
|
(uv-scroll-0 vector4w :inline :offset-assert 8256)
|
|
(uv-scroll-1 vector4w :inline :offset-assert 8272)
|
|
(st-scroll vector2 :inline :offset-assert 8288)
|
|
(wait-to-vu0 uint32 :offset-assert 8296)
|
|
)
|
|
:method-count-assert 92
|
|
:size-assert #x206c
|
|
:flag-assert #x5c0000206c
|
|
(:methods
|
|
(ocean-method-11 () none) ;; 11 ;; (get-height (_type_ vector symbol) float 11)
|
|
(ocean-method-12 () none) ;; 12 ;; (draw! (_type_) none 12)
|
|
(ocean-method-13 () none) ;; 13 ;; (update-map (_type_) none 13)
|
|
(ocean-method-14 () none) ;; 14 ;; (interp-wave (_type_ ocean-wave-info uint float) none 14)
|
|
(ocean-method-15 () none) ;; 15 ;; (ocean-method-15 (_type_ matrix matrix) none 15)
|
|
(ocean-method-16 () none) ;; 16 ;; (generate-verts (_type_ ocean-vert-array ocean-height-array) none 16)
|
|
(ocean-method-17 () none) ;; 17 ;; (add-colors! (_type_ vector ocean-vertex) none 17)
|
|
(ocean-method-18 () none) ;; 18 ;; (ocean-method-18 (_type_ (pointer ocean-colors) (pointer ocean-colors)) none 18)
|
|
(ocean-method-19 () none) ;; 19 ;; (init-buffer! (_type_ dma-buffer) none 19)
|
|
(ocean-method-20 () none) ;; 20 ;; (end-buffer! (_type_ dma-buffer) none 20)
|
|
(ocean-method-21 () none) ;; 21 ;; (set-corners! (_type_ float float) float 21)
|
|
(ocean-method-22 () none) ;; 22 ;; (ocean-near-add-call (_type_ dma-buffer int) none 22)
|
|
(ocean-method-23 () none) ;; 23 ;; (ocean-near-add-call-flush (_type_ dma-buffer int) none 23)
|
|
(ocean-method-24 () none) ;; 24 ;; (ocean-near-setup-constants (_type_ ocean-near-constants) none 24)
|
|
(ocean-method-25 () none) ;; 25 ;; (ocean-near-add-constants (_type_ dma-buffer) none 25)
|
|
(ocean-method-26 () none) ;; 26 ;; (ocean-near-add-heights (_type_ dma-buffer) none 26)
|
|
(ocean-method-27 () none) ;; 27 ;; (ocean-near-add-matrices (_type_ dma-buffer vector) none 27)
|
|
(ocean-method-28 () none) ;; 28 ;; (ocean-near-add-upload (_type_ dma-buffer uint uint) none 28)
|
|
(ocean-method-29 () none) ;; 29 ;; (draw-ocean-near (_type_ dma-buffer) none 29)
|
|
(ocean-method-30 () none) ;; 30 ;; (ocean-trans-camera-masks-bit? (_type_ uint uint) symbol 30)
|
|
(ocean-method-31 () none) ;; 31 ;; (ocean-trans-mask-ptrs-bit? (_type_ int int) symbol 31)
|
|
(ocean-method-32 () none) ;; 32 ;; (ocean-trans-mask-ptrs-set! (_type_ uint uint) symbol 32)
|
|
(ocean-method-33 () none) ;; 33 ;; (ocean-trans-add-upload-table (_type_ dma-buffer uint uint int int symbol) none 33)
|
|
(ocean-method-34 () none) ;; 34 ;; (ocean-trans-add-upload-strip (_type_ dma-buffer uint uint int int int) none 34)
|
|
(ocean-method-35 () none) ;; 35 ;; (ocean-transition-check (_type_ ocean-trans-mask int int vector) none 35)
|
|
(ocean-method-36 () none) ;; 36 ;; (ocean-make-trans-camera-masks (_type_ uint uint uint uint) none 36)
|
|
(ocean-method-37 () none) ;; 37 ;; (ocean-trans-add-upload (_type_ dma-buffer uint uint) none 37)
|
|
(ocean-method-38 () none) ;; 38 ;; (draw-ocean-transition-seams (_type_ dma-buffer) none 38)
|
|
(ocean-method-39 () none) ;; 39 ;; (ocean-trans-add-constants (_type_ dma-buffer) none 39)
|
|
(ocean-method-40 () none) ;; 40 ;; (draw-ocean-transition (_type_ dma-buffer) none 40)
|
|
(ocean-method-41 () none) ;; 41 ;; (ocean-mid-add-call (_type_ dma-buffer int) none 41)
|
|
(ocean-method-42 () none) ;; 42 ;; (ocean-mid-add-call-flush (_type_ dma-buffer uint) none 42)
|
|
(ocean-method-43 () none) ;; 43 ;; (ocean-matrix*! (_type_ matrix matrix matrix) matrix 43)
|
|
(ocean-method-44 () none) ;; 44 ;; (ocean-vector-matrix*! (_type_ vector vector matrix) vector 44)
|
|
(ocean-method-45 () none) ;; 45 ;; (ocean-mid-add-matrices (_type_ dma-buffer vector) none 45)
|
|
(ocean-method-46 () none) ;; 46 ;; (ocean-mid-check (_type_ pointer int int vector) symbol 46)
|
|
(ocean-method-47 () none) ;; 47 ;; (ocean-mid-setup-constants (_type_ ocean-mid-constants) none 47)
|
|
(ocean-method-48 () none) ;; 48 ;; (ocean-mid-add-constants (_type_ dma-buffer) none 48)
|
|
(ocean-method-49 () none) ;; 49 ;; (ocean-mid-camera-masks-bit? (_type_ uint uint) symbol 49)
|
|
(ocean-method-50 () none) ;; 50 ;; (ocean-mid-mask-ptrs-bit? (_type_ uint uint) symbol 50)
|
|
(ocean-method-51 () none) ;; 51 ;; (ocean-mid-camera-masks-set! (_type_ uint uint) symbol 51)
|
|
(ocean-method-52 () none) ;; 52 ;; (ocean-mid-add-upload (_type_ dma-buffer int int int int float) none 52)
|
|
(ocean-method-53 () none) ;; 53 ;; (ocean-mid-add-upload-table (_type_ dma-buffer uint uint (pointer float) int symbol) none 53)
|
|
(ocean-method-54 () none) ;; 54 ;; (ocean-mid-add-upload-top (_type_ dma-buffer uint uint) none 54)
|
|
(ocean-method-55 () none) ;; 55 ;; (ocean-mid-add-upload-middle (_type_ dma-buffer uint uint) none 55)
|
|
(ocean-method-56 () none) ;; 56 ;; (ocean-mid-add-upload-bottom (_type_ dma-buffer uint uint) none 56)
|
|
(ocean-method-57 () none) ;; 57 ;; (ocean-seams-add-constants (_type_ dma-buffer) none 57)
|
|
(ocean-method-58 () none) ;; 58 ;; (draw-ocean-mid-seams (_type_ dma-buffer) none 58)
|
|
(ocean-method-59 () none) ;; 59 ;; (draw-ocean-mid (_type_ dma-buffer) none 59)
|
|
(ocean-method-60 () none) ;; 60 ;; (ocean-method-60 (_type_ dma-buffer) none 60)
|
|
(ocean-method-61 () none) ;; 61 ;; (ocean-method-61 (_type_ dma-buffer) none 61)
|
|
(ocean-method-62 () none) ;; 62 ;; (ocean-method-62 (_type_ dma-buffer) none 62)
|
|
(ocean-method-63 () none) ;; 63 ;; (ocean-method-63 (_type_ dma-buffer) none 63)
|
|
(ocean-method-64 () none) ;; 64 ;; (ocean-method-64 (_type_ dma-buffer) none 64)
|
|
(ocean-method-65 () none) ;; 65 ;; (ocean-method-65 (_type_ dma-buffer) none 65)
|
|
(ocean-method-66 () none) ;; 66 ;; (ocean-method-66 (_type_ dma-buffer) none 66)
|
|
(ocean-method-67 () none) ;; 67 ;; (ocean-method-67 (_type_ dma-buffer) none 67)
|
|
(ocean-method-68 () none) ;; 68 ;; (render-ocean-far (_type_ dma-buffer int) none 68)
|
|
(ocean-method-69 () none) ;; 69 ;; (draw-ocean-far (_type_ dma-buffer) none 69)
|
|
(ocean-method-70 () none) ;; 70 ;; (ocean-texture-setup-constants (_type_ ocean-texture-constants) none 70)
|
|
(ocean-method-71 () none) ;; 71 ;; (ocean-texture-add-constants (_type_ dma-buffer) none 71)
|
|
(ocean-method-72 () none) ;; 72 ;; (ocean-texture-add-envmap (_type_ dma-buffer) none 72)
|
|
(ocean-method-73 () none) ;; 73 ;; (ocean-texture-add-verts (_type_ dma-buffer int) none 73)
|
|
(ocean-method-74 () none) ;; 74 ;; (ocean-texture-add-verts-last (_type_ dma-buffer int int) none 74)
|
|
(ocean-method-75 () none) ;; 75 ;; (ocean-texture-add-call-start (_type_ dma-buffer) none 75)
|
|
(ocean-method-76 () none) ;; 76 ;; (ocean-texture-add-call-rest (_type_ dma-buffer) none 76)
|
|
(ocean-method-77 () none) ;; 77 ;; (ocean-texture-add-call-done (_type_ dma-buffer) none 77)
|
|
(ocean-method-78 () none) ;; 78 ;; (draw-ocean-texture (_type_ dma-buffer int) none 78)
|
|
(ocean-method-79 () none) ;; 79 ;; (ocean-method-79 (_type_ dma-buffer) none 79)
|
|
(ocean-method-80 () none) ;; 80 ;; (ocean-method-80 (_type_ (pointer rgba)) none 80)
|
|
(ocean-method-81 () none) ;; 81 ;; (ocean-method-81 (_type_ dma-buffer) int 81)
|
|
(ocean-method-82 () none) ;; 82 ;; (draw-envmap-debug (_type_ dma-buffer) none 82)
|
|
(ocean-method-83 () none) ;; 83 ;; (ocean-method-83 (_type_ dma-buffer float) none 83)
|
|
(ocean-method-84 () none) ;; 84 ;; (ocean-method-84 (_type_ dma-buffer sky-upload-data vector4w float) none 84)
|
|
(ocean-method-85 () none) ;; 85 ;; (ocean-method-85 (_type_ dma-buffer) none 85)
|
|
(ocean-method-86 () none) ;; 86 ;; (ocean-method-86 (_type_ vector vector vector vector) none 86)
|
|
(ocean-method-87 () none) ;; 87 ;; (ocean-method-87 (_type_ vector vector vector) none 87)
|
|
(ocean-method-88 () none) ;; 88 ;; (ocean-method-88 (_type_ dma-buffer) none 88)
|
|
(ocean-method-89 () none) ;; 89 ;; (ocean-method-89 (_type_ dma-buffer) none 89)
|
|
(ocean-method-90 () none) ;; 90 ;; (rgba-to-vector! (_type_ vector (pointer rgba)) none 90)
|
|
(ocean-method-91 () none) ;; 91 ;; (do-tex-scroll! (_type_) none 91)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ocean-map* object) ;; ocean-map
|
|
;; (define-extern *ocean* object) ;; ocean
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; onintent-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype texture-page-dir (basic)
|
|
()
|
|
:method-count-assert 10
|
|
:size-assert #x14
|
|
:flag-assert #xa00000014
|
|
(:methods
|
|
(texture-page-dir-method-9 () none) ;; 9 ;; (unlink-shaders-in-heap (_type_ kheap) int 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern texture-bpp function) ;; (function gs-psm int)
|
|
;; (define-extern texture-qwc function) ;; (function int int gs-psm int)
|
|
;; (define-extern physical-address function) ;; (function pointer pointer)
|
|
;; (define-extern dma-buffer-add-ref-texture function) ;; (function dma-buffer pointer int int gs-psm none)
|
|
;; (define-extern gs-find-block function) ;; (function int int gs-psm int)
|
|
;; (define-extern gs-page-width function) ;; (function gs-psm int)
|
|
;; (define-extern gs-page-height function) ;; (function gs-psm int)
|
|
;; (define-extern gs-block-width function) ;; (function gs-psm int)
|
|
;; (define-extern gs-block-height function) ;; (function gs-psm int)
|
|
;; (define-extern gs-largest-block function) ;; (function int int gs-psm int)
|
|
;; (define-extern gs-blocks-used function) ;; (function int int gs-psm int)
|
|
;; (define-extern texture-page-default-allocate function) ;; (function texture-pool texture-page kheap int texture-page)
|
|
;; (define-extern texture-page-common-allocate function) ;; (function texture-pool texture-page kheap int texture-page)
|
|
;; (define-extern texture-page-font-allocate function) ;; (function texture-pool texture-page kheap int texture-page)
|
|
;; (define-extern texture-page-common-boot-allocate function) ;; (function texture-pool texture-page kheap int texture-page)
|
|
;; (define-extern upload-vram-data function) ;; (function dma-buffer int pointer int int none)
|
|
;; (define-extern upload-vram-pages function) ;; (function texture-pool texture-pool-segment texture-page tex-upload-mode bucket-id int)
|
|
;; (define-extern update-vram-pages function) ;; (function texture-pool texture-pool-segment texture-page tex-upload-mode int)
|
|
;; (define-extern upload-vram-pages-pris function) ;; (function texture-pool texture-pool-segment texture-page bucket-id (pointer int32) int)
|
|
;; (define-extern texture-page-level-allocate function) ;; (function texture-pool texture-page kheap int texture-page)
|
|
;; (define-extern texture-page-size-check function) ;; (function texture-pool level symbol int)
|
|
;; (define-extern set-skull-gem-masks function) ;; (function none)
|
|
;; (define-extern upload-textures function) ;; (function texture-pool none)
|
|
;; (define-extern *txt-dma-list* object) ;; dma-buffer
|
|
;; (define-extern texture-relocate function) ;; (function dma-buffer texture int gs-psm int dma-buffer)
|
|
;; (define-extern relocate-later function) ;; (function symbol)
|
|
;; (define-extern texture-page-login function) ;; (function texture-id (function texture-pool texture-page kheap int texture-page) kheap texture-page-dir-entry)
|
|
;; (define-extern lookup-texture-by-id function) ;; (function texture-id texture)
|
|
;; (define-extern lookup-texture-by-id-fast function) ;; (function texture-id texture)
|
|
;; (define-extern lookup-texture-by-name function) ;; (function string string (pointer texture-page) texture)
|
|
;; (define-extern lookup-texture-id-by-name function) ;; (function string string texture-id)
|
|
;; (define-extern lookup-level-texture-by-name function) ;; (function string level (pointer texture-page) texture)
|
|
;; (define-extern lookup-tex-id-from-texture function)
|
|
;; (define-extern lookup-level-texture-id-by-name function)
|
|
;; (define-extern *shader-list* object) ;; pair
|
|
;; (define-extern *edit-shader* object) ;; texture-id
|
|
;; (define-extern link-texture-by-id function) ;; (function texture-id adgif-shader texture-page-dir-entry)
|
|
;; (define-extern adgif-shader<-texture! function) ;; (function adgif-shader texture adgif-shader)
|
|
;; (define-extern adgif-shader-update! function) ;; (function adgif-shader texture none)
|
|
;; (define-extern adgif-shader<-texture-with-update! function) ;; (function adgif-shader texture adgif-shader)
|
|
;; (define-extern hack-texture function) ;; (function texture float)
|
|
;; (define-extern adgif-shader-login function) ;; (function adgif-shader texture)
|
|
;; (define-extern adgif-shader-login-no-remap function) ;; (function adgif-shader texture)
|
|
;; (define-extern adgif-shader-login-fast function) ;; (function adgif-shader texture)
|
|
;; (define-extern adgif-shader-login-no-remap-fast function) ;; (function adgif-shader texture)
|
|
;; (define-extern adgif-shader<-texture-simple! function) ;; (function adgif-shader texture adgif-shader)
|
|
;; (define-extern set-dirty-mask! function) ;; (function level int int int none)
|
|
;; (define-extern texture-page-dir-inspect function) ;; (function texture-page-dir symbol none)
|
|
;; (define-extern *texture-pool* object) ;; texture-pool
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prebot-extras ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cav-break-bridge (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-shockwave-joint-position (structure)
|
|
((joint-index int8 :offset-assert 0)
|
|
(position vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-gun-shot (projectile)
|
|
((whoosh-sound uint32 :offset-assert 512)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x204
|
|
:flag-assert #x2901900204
|
|
(:state-methods
|
|
moving ;; 23
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cav-exit-door (process-drawable)
|
|
((initial-y float :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
rise ;; 21
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *prebot-eco-pillar-debris-params* debris-static-params)
|
|
;; (define-extern prebot-eco-pillar-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; main-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype frame-stats (structure)
|
|
((field-time time-frame 2 :offset-assert 0) ;; guessed by decompiler
|
|
(field int32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype screen-filter (basic)
|
|
((draw? symbol :offset-assert 4) ;; guessed by decompiler
|
|
(bucket int32 :offset-assert 8) ;; bucket-id
|
|
(depth int32 :offset-assert 12)
|
|
(ztest uint64 :offset-assert 16)
|
|
(color vector :inline :offset-assert 32)
|
|
(color-src vector :inline :offset-assert 48)
|
|
(color-dest vector :inline :offset-assert 64)
|
|
(extra vector :inline :offset-assert 80)
|
|
(speed float :offset-assert 80)
|
|
(current-interp float :offset-assert 84)
|
|
(lock-vsync? basic :offset-assert 96)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x64
|
|
:flag-assert #xc00000064
|
|
(:methods
|
|
(screen-filter-method-9 () none) ;; 9 ;; (draw (_type_) none 9)
|
|
(screen-filter-method-10 () none) ;; 10 ;; (setup (_type_ vector vector float bucket-id) none 10)
|
|
(screen-filter-method-11 () none) ;; 11 ;; (disable (_type_) none 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype col-rend (basic)
|
|
((draw? symbol :offset-assert 4) ;; guessed by decompiler
|
|
(outline? symbol :offset-assert 8) ;; guessed by decompiler
|
|
(show-back-faces? symbol :offset-assert 12) ;; guessed by decompiler
|
|
(show-normals? symbol :offset-assert 16) ;; guessed by decompiler
|
|
(ghost-hidden? symbol :offset-assert 20) ;; guessed by decompiler
|
|
(show-only uint32 :offset-assert 24)
|
|
(cspec collide-spec :offset-assert 28) ;; guessed by decompiler
|
|
(track uint8 :offset-assert 32)
|
|
(bbox-radius float :offset-assert 36)
|
|
(bbox-center vector :inline :offset-assert 48)
|
|
(camera-to-bbox-dist float :offset-assert 64)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x44
|
|
:flag-assert #xa00000044
|
|
(:methods
|
|
(col-rend-method-9 () none) ;; 9 ;; (col-rend-method-9 (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *stats-poly* object) ;; symbol
|
|
;; (define-extern *stats-memory* object) ;; symbol
|
|
;; (define-extern *stats-memory-short* object) ;; symbol
|
|
;; (define-extern *stats-memory-level-index* object) ;; int
|
|
;; (define-extern *stats-collide* object) ;; symbol
|
|
;; (define-extern *stats-bsp* object) ;; symbol
|
|
;; (define-extern *stats-buffer* object) ;; symbol
|
|
;; (define-extern *stats-target* object) ;; symbol
|
|
;; (define-extern *stats-profile-bars* object) ;; symbol
|
|
;; (define-extern *stats-perf* object) ;; symbol
|
|
;; (define-extern *artist-all-visible* object) ;; symbol
|
|
;; (define-extern *artist-flip-visible* object) ;; symbol
|
|
;; (define-extern *artist-fix-visible* object) ;; symbol
|
|
;; (define-extern *artist-fix-frustum* object) ;; symbol
|
|
;; (define-extern *artist-error-spheres* object) ;; symbol
|
|
;; (define-extern *artist-use-menu-subdiv* object) ;; symbol
|
|
;; (define-extern *display-profile* object) ;; symbol
|
|
;; (define-extern *display-sidekick-stats* object) ;; symbol
|
|
;; (define-extern *display-quad-stats* object) ;; symbol
|
|
;; (define-extern *display-tri-stats* object) ;; symbol
|
|
;; (define-extern *display-ground-stats* object) ;; symbol
|
|
;; (define-extern *display-collision-marks* object) ;; symbol
|
|
;; (define-extern *display-collide-cache* object) ;; symbol
|
|
;; (define-extern *display-render-collision* object) ;; symbol
|
|
;; (define-extern *display-hipri-collision-marks* object) ;; symbol
|
|
;; (define-extern *display-edge-collision-marks* object) ;; symbol
|
|
;; (define-extern *display-geo-marks* object) ;; symbol
|
|
;; (define-extern *display-target-marks* object) ;; symbol
|
|
;; (define-extern *target-rc-board-controls* object) ;; symbol
|
|
;; (define-extern *display-collide-history* object) ;; int
|
|
;; (define-extern *amy-cam* object)
|
|
;; (define-extern *display-xyz-axes* object) ;; symbol
|
|
;; (define-extern *display-cam-collide-history* object) ;; symbol
|
|
;; (define-extern *record-cam-collide-history* object) ;; symbol
|
|
;; (define-extern *display-cam-master-marks* object) ;; symbol
|
|
;; (define-extern *display-cam-other* object) ;; symbol
|
|
;; (define-extern *display-camera-marks* object) ;; symbol
|
|
;; (define-extern *camera-no-mip-correction* object) ;; symbol
|
|
;; (define-extern *camera-turbo-free* object)
|
|
;; (define-extern *display-cam-los-info* object) ;; symbol
|
|
;; (define-extern *display-cam-los-debug* object) ;; symbol
|
|
;; (define-extern *display-cam-los-marks* object) ;; symbol
|
|
;; (define-extern *display-cam-coll-marks* object) ;; symbol
|
|
;; (define-extern *display-camera-info* object) ;; symbol
|
|
;; (define-extern *display-camera-old-stats* object) ;; symbol
|
|
;; (define-extern *display-camera-last-attacker* object) ;; symbol
|
|
;; (define-extern *display-file-info* object) ;; symbol
|
|
;; (define-extern *display-actor-marks* object) ;; symbol
|
|
;; (define-extern *display-sprite-info* object) ;; symbol
|
|
;; (define-extern *display-sprite-marks* object) ;; symbol
|
|
;; (define-extern *display-sprite-spheres* object) ;; symbol
|
|
;; (define-extern *display-entity-errors* object) ;; symbol
|
|
;; (define-extern *display-capture-mode* object)
|
|
;; (define-extern *display-instance-info* object) ;; symbol
|
|
;; (define-extern *display-deci-count* object) ;; symbol
|
|
;; (define-extern *sync-dma* object) ;; symbol
|
|
;; (define-extern *display-strip-lines* object) ;; strip-lines-controls
|
|
;; (define-extern *display-battle-marks* object) ;; symbol
|
|
;; (define-extern *display-joint-axes* object) ;; symbol
|
|
;; (define-extern *display-nav-marks* object) ;; symbol
|
|
;; (define-extern *display-nav-network* object) ;; symbol
|
|
;; (define-extern *display-path-marks* object) ;; symbol
|
|
;; (define-extern *display-vol-marks* object) ;; symbol
|
|
;; (define-extern *display-water-marks* object) ;; symbol
|
|
;; (define-extern *display-nav-mesh* object) ;; symbol
|
|
;; (define-extern *display-race-mesh* object)
|
|
;; (define-extern *display-actor-pointer* object) ;; symbol
|
|
;; (define-extern *display-actor-vis* object) ;; symbol
|
|
;; (define-extern *display-actor-graph* object) ;; symbol
|
|
;; (define-extern *display-traffic-height-map* object) ;; symbol
|
|
;; (define-extern *display-trail-graph* object) ;; symbol
|
|
;; (define-extern *display-color-bars* object) ;; symbol
|
|
;; (define-extern *display-bug-report* object) ;; symbol
|
|
;; (define-extern *display-level-border* object) ;; symbol
|
|
;; (define-extern *display-memcard-info* object) ;; symbol
|
|
;; (define-extern *display-split-boxes* object) ;; symbol
|
|
;; (define-extern *display-split-box-info* object) ;; symbol
|
|
;; (define-extern *display-texture-distances* object) ;; symbol
|
|
;; (define-extern *display-texture-download* object) ;; symbol
|
|
;; (define-extern *display-art-control* object) ;; symbol
|
|
;; (define-extern *display-gui-control* object) ;; symbol
|
|
;; (define-extern *display-level-spheres* object) ;; symbol
|
|
;; (define-extern *time-of-day-fast* object) ;; symbol
|
|
;; (define-extern *display-iop-info* object) ;; symbol
|
|
;; (define-extern *ambient-sound-class* object) ;; symbol
|
|
;; (define-extern *slow-frame-rate* object) ;; symbol
|
|
;; (define-extern *display-region-marks* object) ;; symbol
|
|
;; (define-extern *execute-regions* object) ;; symbol
|
|
;; (define-extern *debug-pause* object) ;; symbol
|
|
;; (define-extern *debug-view-anims* object) ;; symbol
|
|
;; (define-extern *debug-unkillable* object) ;; symbol
|
|
;; (define-extern *debug-player-vehicle-unkillable* object)
|
|
;; (define-extern *debug-actor* object) ;; object
|
|
;; (define-extern *gun-marks* object) ;; symbol
|
|
;; (define-extern *bug-report-output-mode* object) ;; symbol
|
|
;; (define-extern *display-scene-control* object) ;; scene-controls
|
|
;; (define-extern *display-bot-marks* object) ;; bot-marks-controls
|
|
;; (define-extern *display-race-marks* object) ;; race-marks-controls
|
|
;; (define-extern *race-record-path* object) ;; symbol
|
|
;; (define-extern *select-race* object) ;; race-selection
|
|
;; (define-extern *select-race-path* object) ;; int
|
|
;; (define-extern *bot-record-path* object) ;; int
|
|
;; (define-extern *subdivide-draw-mode* object) ;; subdivide-setting
|
|
;; (define-extern *subdivide-scissor-draw-mode* object) ;; subdivide-setting
|
|
;; (define-extern *subdivide-foreground-draw-mode* object) ;; subdivide-setting
|
|
;; (define-extern *subdivide-ocean-draw-mode* object) ;; subdivide-setting
|
|
;; (define-extern *ocean-height-hack* object) ;; ocean-height-hack
|
|
;; (define-extern *dproc* object) ;; process
|
|
;; (define-extern *run* object) ;; symbol
|
|
;; (define-extern *teleport* object) ;; symbol
|
|
;; (define-extern *teleport-count* object) ;; int
|
|
;; (define-extern *draw-hook* object) ;; (function none)
|
|
;; (define-extern *debug-hook* object) ;; pair
|
|
;; (define-extern *menu-hook* object) ;; (function debug-menu-context)
|
|
;; (define-extern *progress-hook* object) ;; (function none)
|
|
;; (define-extern *dma-timeout-hook* object) ;; (function none)
|
|
;; (define-extern *frame-stats* object) ;; frame-stats
|
|
;; (define-extern *col-rend* col-rend) ;; col-rend
|
|
;; (define-extern debug-actor? function) ;; (function object symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hfrag ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *hfrag-debug* object)
|
|
;; (define-extern hfrag-vert-print function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mspace-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype joint (basic)
|
|
((name basic :offset-assert 4)
|
|
(number int32 :offset-assert 8)
|
|
(parent joint :offset-assert 12) ;; guessed by decompiler
|
|
(bind-pose matrix :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone-cache (structure)
|
|
((bone-matrix uint32 :offset-assert 0)
|
|
(parent-matrix uint32 :offset-assert 4)
|
|
(dummy uint32 :offset-assert 8)
|
|
(frame uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone (structure)
|
|
((transform matrix :inline :offset-assert 0)
|
|
(position vector :inline :offset-assert 48)
|
|
(scale vector :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype skeleton (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cspace (structure)
|
|
((parent cspace :offset-assert 0)
|
|
(joint joint :offset-assert 4) ;; guessed by decompiler
|
|
(joint-num int16 :offset-assert 8)
|
|
(geo drawable :offset-assert 12) ;; guessed by decompiler
|
|
(bone bone :offset-assert 16)
|
|
(param0 (function cspace transformq none) :offset-assert 20) ;; guessed by decompiler
|
|
(param1 basic :offset-assert 24)
|
|
(param2 basic :offset-assert 28)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x20
|
|
:flag-assert #xa00000020
|
|
;; field param1 uses ~A with a signed load. field param2 uses ~A with a signed load.
|
|
(:methods
|
|
;; (new (symbol type drawable) _type_ 0)
|
|
(cspace-method-9 () none) ;; 9 ;; (reset-and-assign-geo! (_type_ drawable) _type_ 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cspace-array (inline-array-class)
|
|
((data cspace :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; focus ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype focus (structure)
|
|
((handle uint64 :offset-assert 0) ;; handle
|
|
(collide-with collide-spec :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #xc
|
|
:flag-assert #xd0000000c
|
|
(:methods
|
|
(focus-method-9 () none) ;; 9 ;; (clear-focused (_type_) none 9)
|
|
(focus-method-10 () none) ;; 10 ;; (collide-check? (_type_ process-focusable) object 10)
|
|
(focus-method-11 () none) ;; 11 ;; (reset-to-collide-spec (_type_ collide-spec) none 11)
|
|
(focus-method-12 () none) ;; 12 ;; (try-update-focus (_type_ process-focusable) symbol 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; temple-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype templea-states (structure)
|
|
((flame flames-state :inline :offset-assert 0)
|
|
(rot float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype templed-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
;; (define-extern init-mood-templea function)
|
|
;; (define-extern update-templea-lights function)
|
|
;; (define-extern update-mood-templea function)
|
|
;; (define-extern update-templed-lights function)
|
|
;; (define-extern init-mood-templed function)
|
|
;; (define-extern update-mood-templed function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable-group-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype drawable-group (drawable)
|
|
((id int16 :offset-assert 0)
|
|
(bsphere vector :inline :offset-assert 12)
|
|
(length int16 :offset-assert 2)
|
|
(data drawable :dynamic :offset-assert 28) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factoryc-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype factoryc-states (structure)
|
|
((electricity UNKNOWN 2 :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x27
|
|
:flag-assert #x900000027
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-factoryc function)
|
|
;; (define-extern set-factoryc-light! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; temple-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-color-temple-big-torch-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-temple-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-temple-big-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-temple-big-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-temple-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-temple-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-temple-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-temple-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-temple-big-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-temple-big-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *part-temple-big-torch-flame-curve-settings* object)
|
|
;; (define-extern *range-color-temple-small-torch-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-temple-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-temple-small-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-temple-small-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-temple-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-temple-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-temple-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-temple-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-temple-small-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-temple-small-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *part-temple-small-torch-flame-curve-settings* object)
|
|
;; (define-extern *range-color-templea-small-torch-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-templea-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-templea-small-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-templea-small-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-templea-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-templea-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-templea-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-templea-small-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-templea-small-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-templea-small-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *part-templea-small-torch-flame-curve-settings* object)
|
|
;; (define-extern *range-color-templea-medium-torch-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-templea-medium-torch-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-templea-medium-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-templea-medium-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-templea-medium-torch-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-templea-medium-torch-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-templea-medium-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-templea-medium-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-templea-medium-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-templea-medium-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *part-templea-medium-torch-flame-curve-settings* object)
|
|
;; (define-extern birth-func-temple-shaft-camera-orient function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasall-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *wasall-reserve* object)
|
|
;; (define-extern wasall-login function)
|
|
;; (define-extern wasall-logout function)
|
|
;; (define-extern wasall-activate function)
|
|
;; (define-extern wasall-deactivate function)
|
|
;; (define-extern desert-game-activate function)
|
|
;; (define-extern desert-race-level-activate function)
|
|
;; (define-extern desert-race-level-deactivate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; citizen-enemy ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype citizen-enemy (citizen)
|
|
((next-update-target uint64 :offset-assert 1032) ;; time-frame
|
|
(minimap connection-minimap :offset-assert 1040)
|
|
)
|
|
:method-count-assert 218
|
|
:size-assert #x414
|
|
:flag-assert #xda03a00414
|
|
(:methods
|
|
(citizen-enemy-method-216 () none) ;; 216
|
|
(citizen-enemy-method-217 () none) ;; 217
|
|
)
|
|
(:state-methods
|
|
active ;; 34
|
|
inactive ;; 191
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable-inline-array-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype drawable-inline-array (drawable)
|
|
((length int16 :offset-assert 6)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; game-info ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *default-continue* continue-point) ;; continue-point
|
|
;; (define-extern task-level->string function) ;; (function int string)
|
|
;; (define-extern level-name->task-level function) ;; (function symbol int)
|
|
;; (define-extern trsq->continue-point function) ;; (function trsq int)
|
|
;; (define-extern position->stream function) ;; (function string symbol symbol none)
|
|
;; (define-extern bug-report-display function) ;; (function symbol int)
|
|
;; (define-extern print-continues function) ;; (function int)
|
|
;; (define-extern *highscore-info-array* array) ;; (array highscore-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; draw-node-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype draw-node (drawable)
|
|
((child-count uint8 :offset-assert 6)
|
|
(flags uint8 :offset-assert 7)
|
|
(child drawable :offset-assert 8) ;; guessed by decompiler
|
|
(distance float :offset-assert 12)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
;; field distance is a float printed as hex?
|
|
)
|
|
|#
|
|
|
|
;; (deftype drawable-inline-array-node (drawable-inline-array)
|
|
;; ()
|
|
;; :flag-assert #x1100000044
|
|
;; )
|
|
|
|
#|
|
|
(deftype draw-node-dma (structure)
|
|
((banka draw-node 32 :offset-assert 4) ;; guessed by decompiler
|
|
(bankb draw-node 32 :offset-assert 1028) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x800
|
|
:flag-assert #x900000800
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; path-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype path-control (basic)
|
|
((flags path-control-flag :offset-assert 4) ;; guessed by decompiler
|
|
(name symbol :offset-assert 8) ;; guessed by decompiler
|
|
(process process-drawable :offset-assert 12) ;; guessed by decompiler
|
|
(curve curve :inline :offset-assert 16)
|
|
(num-cverts int32 :offset-assert 20)
|
|
(cverts uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x24
|
|
:flag-assert #x2000000024
|
|
(:methods
|
|
;; (new (symbol type process symbol float entity symbol) _type_ 0)
|
|
(path-control-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(path-control-method-10 () none) ;; 10 ;; (get-point-in-path! (_type_ vector float symbol) vector 10)
|
|
(path-control-method-11 () none) ;; 11 ;; (get-random-point (_type_ vector) vector 11)
|
|
(path-control-method-12 () none) ;; 12 ;; (displacement-between-two-points-copy! (_type_ vector float float) vector 12)
|
|
(path-control-method-13 () none) ;; 13 ;; (displacement-between-two-points-normalized! (_type_ vector float) vector 13)
|
|
(path-control-method-14 () none) ;; 14 ;; (get-point-at-percent-along-path! (_type_ vector float symbol) vector 14)
|
|
(path-control-method-15 () none) ;; 15 ;; (displacement-between-points-at-percent-scaled! (_type_ vector float float) vector 15)
|
|
(path-control-method-16 () none) ;; 16 ;; (displacement-between-points-at-percent-normalized! (_type_ vector float) vector 16)
|
|
(path-control-method-17 () none) ;; 17 ;; (get-num-segments (_type_) float 17)
|
|
(path-control-method-18 () none) ;; 18 ;; (total-distance (_type_) float 18)
|
|
(path-control-method-19 () none) ;; 19 ;; (get-num-verts (_type_) int 19)
|
|
(path-control-method-20 () none) ;; 20 ;; (path-distance-equal-spacing (_type_ float) float 20)
|
|
(path-control-method-21 () none) ;; 21 ;; (average-segment-length (_type_ float) float 21)
|
|
(path-control-method-22 () none) ;; 22 ;; (get-furthest-point-on-path (_type_ vector) float 22)
|
|
(path-control-method-23 () none) ;; 23 ;; (get-path-percentage-at-furthest-point (_type_ vector) float 23)
|
|
(path-control-method-24 () none) ;; 24 ;; (path-control-method-24 (_type_ vector) vector 24)
|
|
(path-control-method-25 () none) ;; 25 ;; (should-display-marks? (_type_) symbol 25)
|
|
(path-control-method-26 () none) ;; 26 ;; (displacement-between-two-points! (_type_ vector float float) vector 26)
|
|
(path-control-method-27 () none) ;; 27
|
|
(path-control-method-28 () none) ;; 28
|
|
(path-control-method-29 () none) ;; 29
|
|
(path-control-method-30 () none) ;; 30
|
|
(path-control-method-31 () none) ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype curve-control (path-control)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #x24
|
|
:flag-assert #x2000000024
|
|
(:methods
|
|
;; (new (symbol type process symbol float) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable-tree-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype drawable-tree (drawable-group)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
;; (deftype drawable-tree-array (drawable-group)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; elevator ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype elevator-params (structure)
|
|
((xz-threshold float :offset-assert 0)
|
|
(y-threshold float :offset-assert 4)
|
|
(start-pos float :offset-assert 8)
|
|
(move-rate float :offset-assert 12)
|
|
(flags uint64 :offset-assert 16) ;; elevator-flags
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype path-step (structure)
|
|
((next-pos float :offset-assert 0)
|
|
(dist float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype path-step-inline-array (inline-array-class)
|
|
((data path-step :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype elevator (base-plat)
|
|
((params elevator-params :inline :offset-assert 272)
|
|
(path-seq path-step-inline-array :offset-assert 296) ;; guessed by decompiler
|
|
(path-dest float :offset-assert 300)
|
|
(bottom-top float 2 :offset-assert 304) ;; guessed by decompiler
|
|
(move-pos float 2 :offset-assert 312) ;; guessed by decompiler
|
|
(move-dist float :offset-assert 320)
|
|
(path-pos float :offset-assert 324)
|
|
(path-eased-pos float :offset-assert 328)
|
|
(ride-timer uint64 :offset-assert 336) ;; time-frame
|
|
(sticky-player-last-ride-time uint64 :offset-assert 344) ;; time-frame
|
|
(elevator-status uint64 :offset-assert 352) ;; elevator-status
|
|
(on-activate pair :offset-assert 360) ;; guessed by decompiler
|
|
(on-deactivate pair :offset-assert 364) ;; guessed by decompiler
|
|
(on-up basic :offset-assert 368)
|
|
(on-down basic :offset-assert 372)
|
|
(on-running basic :offset-assert 376)
|
|
(on-notice basic :offset-assert 380)
|
|
(on-wait basic :offset-assert 384)
|
|
(sound-id uint32 :offset-assert 388)
|
|
(sound-running-loop basic :offset-assert 392)
|
|
(sound-arrived basic :offset-assert 396)
|
|
(fence-prim-index uint32 :offset-assert 400)
|
|
(speed float :offset-assert 404)
|
|
(sound-start basic :offset-assert 408)
|
|
(activate-test basic :offset-assert 412)
|
|
)
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
;; field on-activate uses ~A with a signed load. field on-deactivate uses ~A with a signed load. field on-up uses ~A with a signed load. field on-down uses ~A with a signed load. field on-running uses ~A with a signed load. field on-notice uses ~A with a signed load. field on-wait uses ~A with a signed load. field activate-test uses ~A with a signed load.
|
|
(:methods
|
|
(elevator-method-39 () none) ;; 39 ;; (calc-dist-between-points! (_type_ int int) none 39)
|
|
(elevator-method-41 () none) ;; 41 ;; (init-defaults! (_type_) none 41)
|
|
(elevator-method-42 () none) ;; 42 ;; (set-ambient-sound! (_type_) none 42)
|
|
(elevator-method-43 () none) ;; 43 ;; (move-between-points (_type_ vector float float) symbol 43)
|
|
(elevator-method-44 () none) ;; 44 ;; (elevator-method-44 (_type_) symbol 44)
|
|
(elevator-method-45 () none) ;; 45 ;; (commited-to-ride? (_type_) symbol 45)
|
|
(elevator-method-46 () none) ;; 46 ;; (move-to-next-point! (_type_) none 46)
|
|
(elevator-method-47 () none) ;; 47 ;; (find-closest-point-in-path! (_type_ vector (pointer float) symbol symbol) symbol 47)
|
|
(elevator-method-48 () none) ;; 48 ;; (elevator-method-48 (_type_) none 48)
|
|
(elevator-method-49 () none) ;; 49
|
|
(elevator-method-50 () none) ;; 50
|
|
(elevator-method-51 () none) ;; 51
|
|
)
|
|
(:state-methods
|
|
dormant ;; 35, old: (waiting () _type_ :state 35)
|
|
waiting ;; 36, old: (running () _type_ :state 36)
|
|
running ;; 37, old: (arrived () _type_ :state 37)
|
|
arrived ;; 38, old: (elevator-method-38 (_type_) none 38)
|
|
die ;; 40, old: (activate-elevator (_type_) object 40)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern ease-value-in-out function) ;; (function float float float)
|
|
;; (define-extern elevator-event function) ;; (function process int symbol event-message-block object :behavior elevator)
|
|
;; (define-extern move-post function) ;; (function none :behavior elevator)
|
|
;; (define-extern teleport-check function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-formation ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gen-perms-context (structure)
|
|
((num int32 :offset-assert 0)
|
|
(table uint32 :offset-assert 4)
|
|
(iterate-count int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flying-formation (hover-formation)
|
|
()
|
|
:method-count-assert 16
|
|
:size-assert #x90
|
|
:flag-assert #x1000100090
|
|
)
|
|
|#
|
|
|
|
;; (define-extern gen-perms function) ;; (function int (function int int form-search-info uint) (function form-search-info float) form-search-info symbol)
|
|
;; (define-extern test-gen-perms function) ;; (function int object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable-actor-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype drawable-actor (drawable)
|
|
((actor entity-actor :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
)
|
|
|#
|
|
|
|
;; (deftype drawable-tree-actor (drawable-tree)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
;; (deftype drawable-inline-array-actor (drawable-inline-array)
|
|
;; ()
|
|
;; :flag-assert #x1100000044
|
|
;; )
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sewer-frog ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sewer-frog (nav-enemy)
|
|
((scared-timer uint64 :offset-assert 624)
|
|
)
|
|
:method-count-assert 193
|
|
:size-assert #x278
|
|
:flag-assert #xc102000278
|
|
(:methods
|
|
(sewer-frog-method-192 () none) ;; 192
|
|
)
|
|
(:state-methods
|
|
turn-to-face-focus ;; 191
|
|
knocked ;; 31
|
|
active ;; 34
|
|
stare ;; 37
|
|
hostile ;; 38
|
|
attack ;; 190
|
|
flee ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-sewer-frog-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *sewer-frog-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern sewer-frog-hop function)
|
|
;; (define-extern sewer-frog-turn-to-face function)
|
|
;; (define-extern sewer-frog-check-hop function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; background-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype background-work (basic)
|
|
((tfrag-tree-count int32 :offset-assert 4)
|
|
(tfrag-trees drawable-tree-tfrag 11 :offset-assert 8) ;; guessed by decompiler
|
|
(tfrag-levels level 11 :offset-assert 52) ;; guessed by decompiler
|
|
(tfrag-trans-tree-count int32 :offset-assert 96)
|
|
(tfrag-trans-trees drawable-tree-tfrag-trans 11 :offset-assert 100) ;; guessed by decompiler
|
|
(tfrag-trans-levels level 11 :offset-assert 144) ;; guessed by decompiler
|
|
(tfrag-water-tree-count int32 :offset-assert 188)
|
|
(tfrag-water-trees drawable-tree-tfrag-water 11 :offset-assert 192) ;; guessed by decompiler
|
|
(tfrag-water-levels level 11 :offset-assert 236) ;; guessed by decompiler
|
|
(shrub-tree-count int32 :offset-assert 280)
|
|
(shrub-trees drawable-tree-instance-shrub 11 :offset-assert 284) ;; guessed by decompiler
|
|
(shrub-levels level 11 :offset-assert 328) ;; guessed by decompiler
|
|
(tie-tree-count int32 :offset-assert 372)
|
|
(tie-trees drawable-tree-instance-tie 11 :offset-assert 376) ;; guessed by decompiler
|
|
(tie-levels level 11 :offset-assert 420) ;; guessed by decompiler
|
|
(tie-generic basic 11 :offset-assert 464) ;; guessed by decompiler
|
|
(tie-generic-trans basic 11 :offset-assert 508) ;; guessed by decompiler
|
|
(wait-to-vu0 uint32 :offset-assert 552)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x22c
|
|
:flag-assert #x90000022c
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; region-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype region (structure)
|
|
((id uint32 :offset-assert 0)
|
|
(on-enter pair :offset-assert 4) ;; guessed by decompiler
|
|
(on-inside pair :offset-assert 8) ;; guessed by decompiler
|
|
(on-exit pair :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x10
|
|
:flag-assert #xa00000010
|
|
;; field on-enter uses ~A with a signed load. field on-inside uses ~A with a signed load. field on-exit uses ~A with a signed load.
|
|
(:methods
|
|
(region-method-9 () none) ;; 9 ;; (region-method-9 (_type_ vector) symbol 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype region-array (inline-array-class)
|
|
((data region :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype drawable-region-prim (drawable)
|
|
((region region :offset-assert 8)
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x20
|
|
:flag-assert #x1400000020
|
|
(:methods
|
|
(drawable-region-prim-method-17 () none) ;; 17 ;; (debug-draw-region (_type_ int) none 17)
|
|
(drawable-region-prim-method-18 () none) ;; 18 ;; (track-region (_type_ region-prim-area) symbol 18)
|
|
(drawable-region-prim-method-19 () none) ;; 19 ;; (within-area? (_type_ region-prim-area) symbol 19)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype drawable-tree-region-prim (drawable-tree)
|
|
((id int16 :offset-assert 0)
|
|
(bsphere vector :inline :offset-assert 12)
|
|
(length int16 :offset-assert 2)
|
|
(data drawable :dynamic :offset-assert 28) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(name basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 19
|
|
:size-assert #x20
|
|
:flag-assert #x1300000020
|
|
(:methods
|
|
(drawable-tree-region-prim-method-17 () none) ;; 17 ;; (drawable-tree-region-prim-method-17 (_type_ vector) symbol 17)
|
|
(drawable-tree-region-prim-method-18 () none) ;; 18 ;; (debug-print (_type_ vector object) none 18)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (deftype drawable-inline-array-region-prim (drawable-inline-array)
|
|
;; ()
|
|
;; :flag-assert #x1100000044
|
|
;; )
|
|
|
|
#|
|
|
(deftype drawable-region-sphere (drawable-region-prim)
|
|
()
|
|
:method-count-assert 20
|
|
:size-assert #x20
|
|
:flag-assert #x1400000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype region-face-data (structure)
|
|
((normal vector :inline :offset-assert 0)
|
|
(normal-offset float :offset-assert 12)
|
|
(num-points uint32 :offset-assert 16)
|
|
(points vector :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype drawable-region-face (drawable-region-prim)
|
|
((data region-face-data :offset-assert 12)
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x20
|
|
:flag-assert #x1400000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype region-face-array (inline-array-class)
|
|
((data drawable-region-face :dynamic :offset-assert 20) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x14
|
|
:flag-assert #xe00000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype drawable-region-volume (drawable-region-prim)
|
|
((faces region-face-array :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x20
|
|
:flag-assert #x1400000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype region-prim-list (structure)
|
|
((num-items int32 :offset-assert 0)
|
|
(items drawable-region-prim 320 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x504
|
|
:flag-assert #x900000504
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; power-game ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype power-game-cell (structure)
|
|
((up uint8 :offset-assert 0)
|
|
(right uint8 :offset-assert 1)
|
|
(down uint8 :offset-assert 2)
|
|
(left uint8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype power-game-cam-info (structure)
|
|
((cam-pos vector :inline :offset-assert 0)
|
|
(cam-pos-x-angle deg :offset-assert 16)
|
|
(cam-dist meters :offset-assert 20)
|
|
(cam-x-angle deg :offset-assert 24)
|
|
(cam-y-angle deg :offset-assert 28)
|
|
(cam-y-angle-dest deg :offset-assert 32)
|
|
(cam-y-angle-speed deg :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype power-game (process-drawable)
|
|
((task basic :offset-assert 200)
|
|
(lentity basic :offset-assert 204)
|
|
(hud-score uint64 :offset-assert 208)
|
|
(hud-goal uint64 :offset-assert 216)
|
|
(base-score float :offset-assert 224)
|
|
(score float :offset-assert 228)
|
|
(score-time uint64 :offset-assert 232)
|
|
(score-met basic :offset-assert 240)
|
|
(game uint32 :offset-assert 244)
|
|
(blockers basic :offset-assert 248)
|
|
(dots basic :offset-assert 252)
|
|
(miss-max int32 :offset-assert 256)
|
|
(miss-count int32 :offset-assert 260)
|
|
(miss-time uint64 :offset-assert 264)
|
|
(point-win float :offset-assert 272)
|
|
(game-start-time uint64 :offset-assert 280)
|
|
(wave-start-time uint64 :offset-assert 288)
|
|
(wave-index int32 :offset-assert 296)
|
|
(difficulty int32 :offset-assert 300)
|
|
(speech-time uint64 :offset-assert 304)
|
|
(speech-count int32 :offset-assert 312)
|
|
(speech-last UNKNOWN 8 :offset-assert 316)
|
|
(spawn-time uint64 :offset-assert 352)
|
|
(center vector :inline :offset-assert 368)
|
|
(corner UNKNOWN 2 :offset-assert 384)
|
|
(cam-targ power-game-cam-info :inline :offset-assert 416)
|
|
(cam-cur power-game-cam-info :inline :offset-assert 464)
|
|
(player uint64 :offset-assert 504)
|
|
(chaser uint64 :offset-assert 512)
|
|
(zapper UNKNOWN 5 :offset-assert 520)
|
|
(switcher uint64 :offset-assert 560)
|
|
(switcher-time uint64 :offset-assert 568)
|
|
(glyph uint64 :offset-assert 576)
|
|
(score-part UNKNOWN 1 :offset-assert 584)
|
|
)
|
|
:method-count-assert 46
|
|
:size-assert #x24c
|
|
:flag-assert #x2e01d0024c
|
|
(:methods
|
|
(power-game-method-26 () none) ;; 26
|
|
(power-game-method-27 () none) ;; 27
|
|
(power-game-method-28 () none) ;; 28
|
|
(power-game-method-29 () none) ;; 29
|
|
(power-game-method-30 () none) ;; 30
|
|
(power-game-method-31 () none) ;; 31
|
|
(power-game-method-32 () none) ;; 32
|
|
(power-game-method-33 () none) ;; 33
|
|
(power-game-method-34 () none) ;; 34
|
|
(power-game-method-35 () none) ;; 35
|
|
(power-game-method-36 () none) ;; 36
|
|
(power-game-method-37 () none) ;; 37
|
|
(power-game-method-38 () none) ;; 38
|
|
(power-game-method-39 () none) ;; 39
|
|
(power-game-method-40 () none) ;; 40
|
|
(power-game-method-41 () none) ;; 41
|
|
(power-game-method-42 () none) ;; 42
|
|
(power-game-method-43 () none) ;; 43
|
|
(power-game-method-44 () none) ;; 44
|
|
(power-game-method-45 () none) ;; 45
|
|
)
|
|
(:state-methods
|
|
hide ;; 21
|
|
idle ;; 20
|
|
wait-for-start ;; 22
|
|
active ;; 23
|
|
lose ;; 24
|
|
win ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype power-game-object (process-focusable)
|
|
((local vector :inline :offset-assert 208)
|
|
(dir int8 :offset-assert 224)
|
|
(next-dir int8 :offset-assert 225)
|
|
(slide-dir int8 :offset-assert 226)
|
|
(speed float :offset-assert 228)
|
|
(slide-dist int32 :offset-assert 232)
|
|
(slide-speed float :offset-assert 236)
|
|
(slide-count int32 :offset-assert 240)
|
|
(slide-lock basic :offset-assert 244)
|
|
(slide-dest vector :inline :offset-assert 256)
|
|
(turn-pos vector :inline :offset-assert 272)
|
|
(target uint64 :offset-assert 288)
|
|
(start-time uint64 :offset-assert 296)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x130
|
|
:flag-assert #x2000b00130
|
|
(:methods
|
|
(power-game-object-method-30 () none) ;; 30
|
|
(power-game-object-method-31 () none) ;; 31
|
|
)
|
|
(:state-methods
|
|
active ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype power-game-player (power-game-object)
|
|
((slide-rel-dir int32 :offset-assert 304)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x134
|
|
:flag-assert #x2000c00134
|
|
(:state-methods
|
|
active ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype power-game-chaser (power-game-object)
|
|
((targ-dist float :offset-assert 304)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x134
|
|
:flag-assert #x2000c00134
|
|
(:state-methods
|
|
active ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype power-game-switcher (power-game-object)
|
|
((targ-dist float :offset-assert 304)
|
|
(turn-time uint64 :offset-assert 312)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x140
|
|
:flag-assert #x2100c00140
|
|
(:state-methods
|
|
idle ;; 32
|
|
active ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype power-game-zapper (power-game-object)
|
|
((change-time uint64 :offset-assert 304)
|
|
(close-time uint64 :offset-assert 312)
|
|
(switch-duration uint64 :offset-assert 320)
|
|
(lane-time uint64 :offset-assert 328)
|
|
(lane-target int32 :offset-assert 336)
|
|
(lane-target-old int32 :offset-assert 340)
|
|
(lane-old int32 :offset-assert 344)
|
|
(rings uint32 :offset-assert 348)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x160
|
|
:flag-assert #x2000e00160
|
|
(:state-methods
|
|
active ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype power-game-glyph (power-game-object)
|
|
((pickup-type int32 :offset-assert 304)
|
|
(angle deg :offset-assert 308)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x138
|
|
:flag-assert #x2100c00138
|
|
(:methods
|
|
(power-game-glyph-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern birth-func-power-score function)
|
|
;; (define-extern *power-game-track* object)
|
|
;; (define-extern *power-game* object)
|
|
;; (define-extern *power-game-speech-list* object)
|
|
;; (define-extern power-game-player-post function)
|
|
;; (define-extern power-game-player-init function)
|
|
;; (define-extern power-game-chaser-post function)
|
|
;; (define-extern power-game-chaser-init function)
|
|
;; (define-extern power-game-switcher-post function)
|
|
;; (define-extern power-game-switcher-init function)
|
|
;; (define-extern power-game-zapper-post function)
|
|
;; (define-extern power-game-zapper-init function)
|
|
;; (define-extern power-game-glyph-post function)
|
|
;; (define-extern power-game-glyph-init function)
|
|
;; (define-extern cam-power-game-update function)
|
|
;; (define-extern cam-power-game state)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; needle-fish ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype needle-fish-shot (projectile-bounce)
|
|
((scale float :offset-assert 548)
|
|
)
|
|
:method-count-assert 44
|
|
:size-assert #x228
|
|
:flag-assert #x2c01b00228
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype needle-fish-chain-physics (chain-physics)
|
|
()
|
|
:method-count-assert 18
|
|
:size-assert #x570
|
|
:flag-assert #x1200000570
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype needle-fish (nav-enemy)
|
|
((scared-timer uint64 :offset-assert 624)
|
|
(tail basic :offset-assert 632)
|
|
(tail-initialized basic :offset-assert 636)
|
|
(tail-clock float :offset-assert 640)
|
|
(tail-blend float :offset-assert 644)
|
|
)
|
|
:method-count-assert 192
|
|
:size-assert #x288
|
|
:flag-assert #xc002100288
|
|
(:state-methods
|
|
active ;; 34
|
|
notice ;; 35
|
|
stare ;; 37
|
|
hostile ;; 38
|
|
attack ;; 190
|
|
explode ;; 191
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-needle-fish (needle-fish)
|
|
()
|
|
:method-count-assert 192
|
|
:size-assert #x288
|
|
:flag-assert #xc002100288
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spawn-needle-fish-projectile function)
|
|
;; (define-extern *needle-fish-spike-tbl* array)
|
|
;; (define-extern *needle-fish-chain-setup* array)
|
|
;; (define-extern *fact-info-needle-fish-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *needle-fish-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern needle-fish-joint-mod-tail function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; traffic-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype traffic-danger-info (structure)
|
|
((sphere sphere :inline :offset-assert 0)
|
|
(velocity vector :inline :offset-assert 16)
|
|
(handle uint64 :offset-assert 32) ;; handle
|
|
(notify-radius float :offset-assert 40)
|
|
(danger-level float :offset-assert 44)
|
|
(decay-rate float :offset-assert 48)
|
|
(flags uint8 :offset-assert 52) ;; traffic-danger-flags
|
|
(danger-type uint8 :offset-assert 53) ;; traffic-danger-type
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x36
|
|
:flag-assert #x900000036
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-suppression-params (structure)
|
|
((bbox bounding-box :inline :offset-assert 0)
|
|
(duration uint64 :offset-assert 32) ;; time-frame
|
|
(id int8 :offset-assert 40)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x29
|
|
:flag-assert #xd00000029
|
|
(:methods
|
|
(traffic-suppression-params-method-9 () none) ;; 9 ;; (try-creating-new-suppression-box (_type_) symbol 9)
|
|
(traffic-suppression-params-method-10 () none) ;; 10 ;; (create-or-update-suppression-box (_type_) symbol 10)
|
|
(traffic-suppression-params-method-11 () none) ;; 11 ;; (has-valid-id? (_type_) none 11)
|
|
(traffic-suppression-params-method-12 () none) ;; 12 ;; (kill-suppression-box (_type_) none 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-object-spawn-params (structure)
|
|
((object-type uint8 :offset-assert 0) ;; traffic-type
|
|
(behavior uint64 :offset-assert 8)
|
|
(id uint32 :offset-assert 16)
|
|
(nav-mesh nav-mesh :offset-assert 20) ;; guessed by decompiler
|
|
(nav-branch nav-branch :offset-assert 24) ;; guessed by decompiler
|
|
(position vector :inline :offset-assert 32)
|
|
(rotation quaternion :inline :offset-assert 48)
|
|
(velocity vector :inline :offset-assert 64)
|
|
(handle uint64 :offset-assert 80) ;; handle
|
|
(handle-parent uint64 :offset-assert 88)
|
|
(guard-type uint8 :offset-assert 96)
|
|
(user-data uint32 :offset-assert 100)
|
|
(entity basic :offset-assert 104)
|
|
(flags traffic-spawn-flags :offset-assert 108) ;; guessed by decompiler
|
|
(proc process :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x74
|
|
:flag-assert #x900000074
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-info (structure)
|
|
((ctywide-level basic :offset-assert 0)
|
|
(vehicle-level basic :offset-assert 4)
|
|
(race-vehicle-level basic :offset-assert 8)
|
|
(traffic-object-levels UNKNOWN 29 :offset-assert 12)
|
|
(vehicle-levels UNKNOWN 44 :offset-assert 128)
|
|
(traffic-object-type-from-vehicle-type UNKNOWN 44 :offset-assert 304)
|
|
(restore-speech-callback basic :offset-assert 348)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x160
|
|
:flag-assert #x900000160
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *traffic-manager* object) ;; traffic-manager
|
|
;; (define-extern *vehicle-manager* object)
|
|
;; (define-extern *traffic-info* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; game-task-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hud ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-sprite-work (structure)
|
|
((adgif-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(sprite-tmpl dma-gif-packet :inline :offset-assert 32)
|
|
(draw-tmpl dma-gif-packet :inline :offset-assert 64)
|
|
(box-tmpl dma-gif-packet :inline :offset-assert 96)
|
|
(box2-tmpl dma-gif-packet :inline :offset-assert 128)
|
|
(mask-tmpl dma-gif-packet :inline :offset-assert 160)
|
|
(line-tmpl dma-gif-packet :inline :offset-assert 192)
|
|
(scan-tmpl dma-gif-packet :inline :offset-assert 224)
|
|
(line-color uint64 :offset-assert 256) ;; gs-rgbaq
|
|
(scan-colors vector4w 32 :offset-assert 272) ;; guessed by decompiler
|
|
(scanline uint32 :offset-assert 784)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x314
|
|
:flag-assert #x900000314
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *hud-sprite-work* object) ;; hud-sprite-work
|
|
;; (define-extern hud-create-icon function) ;; (function hud int int (pointer manipy))
|
|
;; (define-extern hud-hidden-event-handler function)
|
|
;; (define-extern hud-init-by-other function) ;; (function object :behavior hud)
|
|
;; (define-extern hide-hud function) ;; (function symbol none)
|
|
;; (define-extern enable-hud function) ;; (function none)
|
|
;; (define-extern hide-hud-quick function) ;; (function symbol none)
|
|
;; (define-extern show-hud function) ;; (function object none)
|
|
;; (define-extern ready-hud function)
|
|
;; (define-extern hud-hidden? function) ;; (function symbol)
|
|
;; (define-extern set-hud-piece-position! function) ;; (function hud-sprite int int none)
|
|
;; (define-extern set-as-offset-from! function) ;; (function hud-sprite vector4w int int none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; progress ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-ring-cell (process-drawable)
|
|
((joint-idx int32 :offset-assert 200)
|
|
(init-angle float :offset-assert 204) ;; degrees
|
|
(graphic-index int32 :offset-assert 208)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xd4
|
|
:flag-assert #x15006000d4
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *progress-stack* object) ;; (pointer uint8)
|
|
;; (define-extern *progress-process* object) ;; (pointer progress)
|
|
;; (define-extern *progress-save-info* object) ;; mc-slot-info
|
|
;; (define-extern *progress-work* object)
|
|
;; (define-extern min-max-wrap-around function) ;; (function int int int int)
|
|
;; (define-extern progress-intro-start function) ;; (function symbol int)
|
|
;; (define-extern hud-ring-cell-remap function)
|
|
;; (define-extern hud-ring-cell-init-by-other function) ;; (function int float int object :behavior hud-ring-cell)
|
|
;; (define-extern progress-init-by-other function) ;; (function symbol object :behavior progress)
|
|
;; (define-extern set-ring-position function) ;; (function progress float)
|
|
;; (define-extern activate-progress function) ;; (function process symbol none)
|
|
;; (define-extern deactivate-progress function) ;; (function none)
|
|
;; (define-extern hide-progress-screen function) ;; (function none)
|
|
;; (define-extern progress-allowed? function) ;; (function symbol)
|
|
;; (define-extern progress-trans function) ;; (function none :behavior progress)
|
|
;; (define-extern begin-scan function) ;; (function hud-box progress int)
|
|
;; (define-extern end-scan function) ;; (function hud-box float int)
|
|
;; (define-extern progress-post function) ;; (function none :behavior progress)
|
|
;; (define-extern *last-powerup-collect-amount* object)
|
|
;; (define-extern spawn-secret-notify-message function)
|
|
;; (define-extern menu-secrets-notify-task-node-close function)
|
|
;; (define-extern menu-secrets-notify-powerup-collect function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rpc-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rpc-buffer (basic)
|
|
((elt-size uint32 :offset-assert 4)
|
|
(elt-count uint32 :offset-assert 8)
|
|
(elt-used uint32 :offset-assert 12)
|
|
(busy basic :offset-assert 16)
|
|
(base pointer :offset-assert 20) ;; guessed by decompiler
|
|
(data uint8 :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rpc-buffer-pair (basic)
|
|
((buffer rpc-buffer 2 :offset-assert 4) ;; guessed by decompiler
|
|
(current rpc-buffer :offset-assert 12) ;; guessed by decompiler
|
|
(last-recv-buffer pointer :offset-assert 16) ;; guessed by decompiler
|
|
(rpc-port int32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x18
|
|
:flag-assert #xf00000018
|
|
(:methods
|
|
;; (new (symbol type uint uint int) rpc-buffer-pair 0)
|
|
(rpc-buffer-pair-method-9 () none) ;; 9 ;; (call (rpc-buffer-pair uint pointer uint) int 9)
|
|
(rpc-buffer-pair-method-10 () none) ;; 10 ;; (add-element (rpc-buffer-pair) pointer 10)
|
|
(rpc-buffer-pair-method-11 () none) ;; 11 ;; (decrement-elt-used (rpc-buffer-pair) int 11)
|
|
(rpc-buffer-pair-method-12 () none) ;; 12 ;; (sync (rpc-buffer-pair symbol) int 12)
|
|
(rpc-buffer-pair-method-13 () none) ;; 13 ;; (check-busy (rpc-buffer-pair) symbol 13)
|
|
(rpc-buffer-pair-method-14 () none) ;; 14 ;; (pop-last-received (rpc-buffer-pair) pointer 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; terraformer-head ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype terraformer-head-speech-instance (structure)
|
|
((speech basic :offset-assert 0)
|
|
(probability float :offset-assert 4)
|
|
(flags uint64 :offset-assert 8)
|
|
(play-count uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-head-speech-info (structure)
|
|
((speeches basic :offset-assert 0)
|
|
(play-time uint64 :offset-assert 8)
|
|
(current-random uint64 :offset-assert 16)
|
|
(minimum-interval uint64 :offset-assert 24)
|
|
(random-interval uint64 :offset-assert 32)
|
|
(last-played int8 :offset-assert 40)
|
|
(flags uint8 :offset-assert 41)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2a
|
|
:flag-assert #x90000002a
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-head-speech-group (structure)
|
|
((play-time uint64 :offset-assert 0)
|
|
(info basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-disc-look-at (basic)
|
|
((flags uint32 :offset-assert 4)
|
|
(up int8 :offset-assert 8)
|
|
(nose int8 :offset-assert 9)
|
|
(target vector :inline :offset-assert 16)
|
|
(blend-duration uint64 :offset-assert 32)
|
|
(blend-start-time uint64 :offset-assert 40)
|
|
(blend-start-value float :offset-assert 48)
|
|
(blend-max float :offset-assert 52)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x38
|
|
:flag-assert #xe00000038
|
|
(:methods
|
|
(joint-mod-disc-look-at-method-9 () none) ;; 9
|
|
(joint-mod-disc-look-at-method-10 () none) ;; 10
|
|
(joint-mod-disc-look-at-method-11 () none) ;; 11
|
|
(joint-mod-disc-look-at-method-12 () none) ;; 12
|
|
(joint-mod-disc-look-at-method-13 () none) ;; 13
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-head-target (process-focusable)
|
|
((been-hit basic :offset-assert 208)
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #xd4
|
|
:flag-assert #x1d006000d4
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-head-laser-projectile (projectile)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x200
|
|
:flag-assert #x2901800200
|
|
(:state-methods
|
|
moving ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-head-critter-tracker (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(flags uint32 :offset-assert 8)
|
|
(dest vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-head-ammo-tracker (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(where vector :inline :offset-assert 16)
|
|
(birth-next-time basic :offset-assert 32)
|
|
(timer uint64 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-head (process-focusable)
|
|
((head-aim-jm basic :offset-assert 208)
|
|
(neck-aim-jm basic :offset-assert 212)
|
|
(target-spline tracking-spline :inline :offset-assert 224)
|
|
(target-position vector :inline :offset-assert 1872)
|
|
(beam-projectile uint64 :offset-assert 1888)
|
|
(hit-points float :offset-assert 1896)
|
|
(stage uint8 :offset-assert 1900)
|
|
(incoming-attack-id uint32 :offset-assert 1904)
|
|
(flags uint64 :offset-assert 1912)
|
|
(initial-position vector :inline :offset-assert 1920)
|
|
(position-seeker cam-vector-seeker :inline :offset-assert 1936)
|
|
(actor-group uint32 :offset-assert 1996)
|
|
(actor-group-count int32 :offset-assert 2000)
|
|
(vulnerable-timer uint64 :offset-assert 2008)
|
|
(very-vulnerable-timer uint64 :offset-assert 2016)
|
|
(num-attacks int8 :offset-assert 2024)
|
|
(current-round int8 :offset-assert 2025)
|
|
(command-index int8 :offset-assert 2026)
|
|
(command-timer uint64 :offset-assert 2032)
|
|
(critter UNKNOWN 8 :offset-assert 2048)
|
|
(terraformer-head-target uint64 :offset-assert 2304)
|
|
(light-vent-timer uint64 :offset-assert 2312)
|
|
(light-vent-connection connection :offset-assert 2320)
|
|
(dark-vent-timer uint64 :offset-assert 2328)
|
|
(dark-vent-connection connection :offset-assert 2336)
|
|
(ammo UNKNOWN 20 :offset-assert 2352)
|
|
(laser-sound-id uint32 :offset-assert 3312)
|
|
(warmup-sound-id uint32 :offset-assert 3316)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xcf8
|
|
:flag-assert #x210c800cf8
|
|
(:state-methods
|
|
run-script ;; 28
|
|
take-hit ;; 29
|
|
swing-laser ;; 30
|
|
slam ;; 31
|
|
initial-state ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-head-command (structure)
|
|
((action uint64 :offset-assert 0)
|
|
(suck float :offset-assert 8)
|
|
(random float :offset-assert 12)
|
|
(round int8 :offset-assert 16)
|
|
(num float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *terraformer-head-speech* object)
|
|
;; (define-extern reset-terraformer-head-speeches function)
|
|
;; (define-extern terraformer-head-play-speech function)
|
|
;; (define-extern joint-mod-disc-look-at-callback function)
|
|
;; (define-extern terraformer-head-target-init-by-other function)
|
|
;; (define-extern *terraformer-head-shadow-control* shadow-control)
|
|
;; (define-extern terraformer-head-get-actor-group function)
|
|
;; (define-extern terraformer-head-send-group-event function)
|
|
;; (define-extern terraformer-head-fire-beam function)
|
|
;; (define-extern terraformer-head-connect-tank-glows function)
|
|
;; (define-extern terraformer-head-always function)
|
|
;; (define-extern terraformer-head-always-handler function)
|
|
;; (define-extern terraformer-head-handler function)
|
|
;; (define-extern *terraformer-head-swarm-0* array)
|
|
;; (define-extern *terraformer-head-swarm-1* array)
|
|
;; (define-extern *terraformer-head-swarm-2* array)
|
|
;; (define-extern terraformer-head-point-occupied? function)
|
|
;; (define-extern terraformer-head-get-spawn-point function)
|
|
;; (define-extern terraformer-head-launch-critter function)
|
|
;; (define-extern terraformer-head-advance-launch-script function)
|
|
;; (define-extern terraformer-head-check-launch-script function)
|
|
;; (define-extern terraformer-head-target-enable function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; height-map ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern point-in-bbox? function) ;; (function bounding-box vector symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; task-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype game-task-event (basic)
|
|
;; ()
|
|
;; :flag-assert #x900000010
|
|
;; )
|
|
|
|
#|
|
|
(deftype resetter-spec (structure)
|
|
((continue basic :offset-assert 0)
|
|
(node uint16 :offset-assert 4)
|
|
(reset-mode basic :offset-assert 8)
|
|
(execute basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
;; field execute uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype resetter-params (structure)
|
|
((message uint8 :offset-assert 0)
|
|
(flags resetter-flag :offset-assert 2)
|
|
(fail resetter-spec :inline :offset-assert 4)
|
|
(retry resetter-spec :inline :offset-assert 20)
|
|
(reset-delay uint32 :offset-assert 36)
|
|
(task uint8 :offset-assert 40)
|
|
(text-message uint32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
;; field resetter-flag is likely a value type.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-info (structure)
|
|
((mask task-manager-mask :offset-assert 0)
|
|
(level symbol :offset-assert 4) ;; guessed by decompiler
|
|
(type-to-spawn basic :offset-assert 8)
|
|
(time-limit int32 :offset-assert 12)
|
|
(manager handle :offset-assert 16)
|
|
(intro-scene string :offset-assert 24) ;; guessed by decompiler
|
|
(resolution-scene string :offset-assert 28) ;; guessed by decompiler
|
|
(resolution-scene-continue string :offset-assert 32) ;; guessed by decompiler
|
|
(final-node uint16 :offset-assert 36) ;; game-task-node
|
|
(vehicle-type uint8 :offset-assert 38)
|
|
(sphere-count int8 :offset-assert 39)
|
|
(index int8 :offset-assert 40)
|
|
(intro-delay uint16 :offset-assert 42)
|
|
(sphere-array uint32 :offset-assert 44)
|
|
(on-complete pair :offset-assert 48) ;; guessed by decompiler
|
|
(on-fail pair :offset-assert 52) ;; guessed by decompiler
|
|
(user-count int32 :offset-assert 56)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
;; field handle is likely a value type. field resolution-scene uses ~A with a signed load. field on-complete uses ~A with a signed load. field on-fail uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-reset-info (structure)
|
|
((restart-info resetter-params :offset-assert 0)
|
|
(quit-info resetter-params :offset-assert 4)
|
|
(fail-info resetter-params :offset-assert 8)
|
|
(death-info resetter-params :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype game-task-node-info (basic)
|
|
((level symbol :offset-assert 4) ;; guessed by decompiler
|
|
(name string :offset-assert 12) ;; guessed by decompiler
|
|
(when-open (array game-task-event) :offset-assert 16) ;; guessed by decompiler
|
|
(flags game-task-node-flag :offset-assert 20)
|
|
(parent-node game-task-node 4 :offset-assert 24) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(task-mask task-mask :offset-assert 32)
|
|
(on-open pair :offset-assert 36) ;; guessed by decompiler
|
|
(manager task-manager-info :offset-assert 40)
|
|
(borrow pair :offset-assert 44) ;; guessed by decompiler
|
|
(open? (function game-task-node-info symbol) :offset-assert 48) ;; guessed by decompiler
|
|
(on-close pair :offset-assert 52) ;; guessed by decompiler
|
|
(close-time time-frame :offset-assert 56) ;; guessed by decompiler
|
|
(reset task-reset-info :offset-assert 60)
|
|
(gem-count uint16 :offset-assert 64)
|
|
(skill-count uint16 :offset-assert 66)
|
|
(death-count uint8 :offset-assert 68) ;; uint16
|
|
(suck-death-count uint8 :offset-assert 69)
|
|
(command-index uint8 :offset-assert 70)
|
|
(command-count uint8 :offset-assert 71)
|
|
(description text-id :offset-assert 72) ;; guessed by decompiler
|
|
(faction-commands basic :offset-assert 76)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x50
|
|
:flag-assert #xe00000050
|
|
;; field on-open uses ~A with a signed load. field on-close uses ~A with a signed load.
|
|
(:methods
|
|
(game-task-node-info-method-9 () none) ;; 9 ;; (close! (_type_ symbol) int 9)
|
|
(game-task-node-info-method-10 () none) ;; 10 ;; (open! (_type_ symbol) int 10)
|
|
(game-task-node-info-method-11 () none) ;; 11 ;; (open? (_type_) symbol 11)
|
|
(game-task-node-info-method-12 () none) ;; 12 ;; (copy-hooks! (_type_ game-task-node-info) game-task-node-info 12)
|
|
(game-task-node-info-method-13 () none) ;; 13 ;; (eval-add (_type_) int 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype game-task-info (basic)
|
|
((name string :offset-assert 4) ;; guessed by decompiler
|
|
(text-name text-id :offset-assert 8) ;; guessed by decompiler
|
|
(pre-play-node uint16 :offset-assert 12) ;; game-task-node
|
|
(kiosk-play-node uint16 :offset-assert 14) ;; game-task-node
|
|
(pre-play-continue string :offset-assert 16) ;; guessed by decompiler
|
|
(play-node uint16 :offset-assert 20) ;; game-task-node
|
|
(play-continue string :offset-assert 24) ;; guessed by decompiler
|
|
(kiosk-play-continue string :offset-assert 28) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x20
|
|
:flag-assert #xa00000020
|
|
;; field kiosk-play-continue uses ~A with a signed load.
|
|
(:methods
|
|
(game-task-info-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (deftype game-task-control (basic)
|
|
;; ()
|
|
;; :flag-assert #xa00000010
|
|
;; )
|
|
|
|
#|
|
|
(deftype task-manager (process)
|
|
((node-info game-task-node-info :offset-assert 128) ;; guessed by decompiler
|
|
(info task-manager-info :offset-assert 132)
|
|
(lev-name symbol :offset-assert 136) ;; guessed by decompiler
|
|
(fail-on-death? symbol :offset-assert 140) ;; guessed by decompiler
|
|
(fail-now symbol :offset-assert 144) ;; guessed by decompiler
|
|
(restart-now basic :offset-assert 148)
|
|
(allow-fail symbol :offset-assert 152) ;; guessed by decompiler
|
|
(state-time uint64 :offset-assert 160) ;; time-frame
|
|
(start-time uint64 :offset-assert 168) ;; time-frame
|
|
(time-limit uint64 :offset-assert 176) ;; time-frame
|
|
(arrow uint64 :offset-assert 184) ;; handle
|
|
(player-vehicle uint64 :offset-assert 192)
|
|
(hud handle 4 :offset-assert 200) ;; guessed by decompiler
|
|
(hud-timer uint64 :offset-assert 200) ;; handle
|
|
(hud-counter uint64 :offset-assert 208) ;; handle
|
|
(intro-time uint64 :offset-assert 232) ;; time-frame
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:methods
|
|
(task-manager-method-14 () none) ;; 14 ;; (wait () _type_ :state 14)
|
|
(task-manager-method-15 () none) ;; 15 ;; (active () _type_ :state 15)
|
|
(task-manager-method-16 () none) ;; 16 ;; (complete () _type_ :state 16)
|
|
(task-manager-method-17 () none) ;; 17 ;; (fail () _type_ :state 17)
|
|
(task-manager-method-18 () none) ;; 18 ;; (retry () _type_ :state 18)
|
|
(task-manager-method-19 () none) ;; 19 ;; (initialize! (_type_) int 19)
|
|
(task-manager-method-20 () none) ;; 20 ;; (kill-all-children (_type_) int 20)
|
|
(task-manager-method-21 () none) ;; 21 ;; (check-time (_type_) int 21)
|
|
(task-manager-method-22 () none) ;; 22 ;; (task-manager-method-22 (_type_) symbol 22)
|
|
(task-manager-method-23 () none) ;; 23
|
|
(task-manager-method-24 () none) ;; 24
|
|
(task-manager-method-25 () none) ;; 25
|
|
(task-manager-method-26 () none) ;; 26
|
|
(task-manager-method-27 () none) ;; 27
|
|
(task-manager-method-28 () none) ;; 28
|
|
(task-manager-method-29 () none) ;; 29
|
|
(task-manager-method-30 () none) ;; 30
|
|
(task-manager-method-31 () none) ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ambient-control (structure)
|
|
((last-ambient-time uint64 :offset-assert 0) ;; time-frame
|
|
(last-ambient string :offset-assert 8) ;; guessed by decompiler
|
|
(last-ambient-id sound-id :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x10
|
|
:flag-assert #xc00000010
|
|
(:methods
|
|
(ambient-control-method-9 () none) ;; 9 ;; (dummy-9 () none 9)
|
|
(ambient-control-method-10 () none) ;; 10 ;; (dummy-10 () none 10)
|
|
(ambient-control-method-11 () none) ;; 11 ;; (dummy-11 () none 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern game-task->string function) ;; (function game-task string)
|
|
;; (define-extern c-string->game-task function) ;; (function string game-task)
|
|
;; (define-extern game-task-actor->string function) ;; (function game-task-actor string)
|
|
;; (define-extern game-task-action->string function) ;; (function game-task-action string)
|
|
;; (define-extern game-task-node-flag->string function) ;; (function game-task-node-flag object)
|
|
;; (define-extern game-task-node-command->string function) ;; (function game-task-node-command string)
|
|
;; (define-extern *traffic-engine* object) ;; traffic-engine
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pecker-ingame ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pecker-ingame (process-drawable)
|
|
((path-u float :offset-assert 200)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xcc
|
|
:flag-assert #x17005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
die ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern pecker-ingame-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-graph-editor ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-graph-command (structure)
|
|
((com-type uint32 :offset-assert 0)
|
|
(id int32 :offset-assert 4)
|
|
(index int32 :offset-assert 8)
|
|
(move-vec vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-graph-command-array (inline-array-class)
|
|
((data nav-graph-command :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-graph-editor (process)
|
|
((nav-graph mysql-nav-graph :offset-assert 128) ;; guessed by decompiler
|
|
(mode symbol :offset-assert 132) ;; guessed by decompiler
|
|
(command-id int32 :offset-assert 136)
|
|
(max-command int32 :offset-assert 140)
|
|
(selected-index int32 :offset-assert 144)
|
|
(selected-dist float :offset-assert 148)
|
|
(selected-node-edge? symbol :offset-assert 152) ;; guessed by decompiler
|
|
(closest-node int32 :offset-assert 156)
|
|
(dist-closest-node float :offset-assert 160)
|
|
(closest-edge int32 :offset-assert 164)
|
|
(dist-closest-edge float :offset-assert 168)
|
|
(mouse-pos vector :inline :offset-assert 176)
|
|
(mouse-hit vector :inline :offset-assert 192)
|
|
(mouse-hit-pick vector :inline :offset-assert 208)
|
|
(mouse-normal vector :inline :offset-assert 224)
|
|
(mouse-spos-hold vector :inline :offset-assert 240)
|
|
(edge-src int32 :offset-assert 256)
|
|
(edge-dst int32 :offset-assert 260)
|
|
(edge-visibility int32 :offset-assert 264)
|
|
(vehicle-edit-mode symbol :offset-assert 268) ;; guessed by decompiler
|
|
(hover-edit-mode symbol :offset-assert 272) ;; guessed by decompiler
|
|
(plane-height float :offset-assert 276)
|
|
(plane-height-hold float :offset-assert 280)
|
|
(minimap-make-mode uint8 :offset-assert 284)
|
|
(clipping-dist float :offset-assert 288)
|
|
(default-node mysql-nav-node :inline :offset-assert 304)
|
|
(default-edge mysql-nav-edge :inline :offset-assert 380)
|
|
(command-array nav-graph-command-array :offset-assert 456) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 68
|
|
:size-assert #x1cc
|
|
:flag-assert #x44015001cc
|
|
(:methods
|
|
(nav-graph-editor-method-29 () none) ;; 29 ;; (nav-graph-editor-method-29 (_type_ string string string) none 29)
|
|
(nav-graph-editor-method-30 () none) ;; 30 ;; (nav-graph-editor-method-30 (_type_ int) symbol 30)
|
|
(nav-graph-editor-method-31 () none) ;; 31 ;; (nav-graph-editor-method-31 (_type_ int) symbol 31)
|
|
(nav-graph-editor-method-32 () none) ;; 32 ;; (nav-graph-editor-method-32 (_type_ symbol int) none 32)
|
|
(nav-graph-editor-method-33 () none) ;; 33 ;; (nav-graph-editor-method-33 (_type_ int) none 33)
|
|
(nav-graph-editor-method-34 () none) ;; 34 ;; (nav-graph-editor-method-34 (_type_) object 34)
|
|
(nav-graph-editor-method-35 () none) ;; 35 ;; (nav-graph-editor-method-35 (_type_) none 35)
|
|
(nav-graph-editor-method-36 () none) ;; 36 ;; (nav-graph-editor-method-36 (_type_) none 36)
|
|
(nav-graph-editor-method-37 () none) ;; 37 ;; (nav-graph-editor-method-37 (_type_) none 37)
|
|
(nav-graph-editor-method-38 () none) ;; 38 ;; (nav-graph-editor-method-38 (_type_) none 38)
|
|
(nav-graph-editor-method-39 () none) ;; 39 ;; (nav-graph-editor-method-39 (_type_) none 39)
|
|
(nav-graph-editor-method-40 () none) ;; 40 ;; (nav-graph-editor-method-40 (_type_) none 40)
|
|
(nav-graph-editor-method-41 () none) ;; 41 ;; (nav-graph-editor-method-41 (_type_) none 41)
|
|
(nav-graph-editor-method-42 () none) ;; 42 ;; (nav-graph-editor-method-42 (_type_) symbol 42)
|
|
(nav-graph-editor-method-43 () none) ;; 43 ;; (nav-graph-editor-method-43 (_type_) none 43)
|
|
(nav-graph-editor-method-44 () none) ;; 44 ;; (nav-graph-editor-method-44 (_type_) symbol 44)
|
|
(nav-graph-editor-method-45 () none) ;; 45 ;; (nav-graph-editor-method-45 (_type_) none 45)
|
|
(nav-graph-editor-method-46 () none) ;; 46 ;; (nav-graph-editor-method-46 (_type_) pad-buttons 46)
|
|
(nav-graph-editor-method-47 () none) ;; 47 ;; (nav-graph-editor-method-47 (_type_) none 47)
|
|
(nav-graph-editor-method-48 () none) ;; 48 ;; (nav-graph-editor-method-48 (_type_ uint) nav-graph-command 48)
|
|
(nav-graph-editor-method-49 () none) ;; 49 ;; (nav-graph-editor-method-49 (_type_) nav-graph-command 49)
|
|
(nav-graph-editor-method-50 () none) ;; 50 ;; (nav-graph-editor-method-50 (_type_) none 50)
|
|
(nav-graph-editor-method-51 () none) ;; 51 ;; (nav-graph-editor-method-51 (_type_) none 51)
|
|
(nav-graph-editor-method-52 () none) ;; 52 ;; (nav-graph-editor-method-52 (_type_) uint 52)
|
|
(nav-graph-editor-method-53 () none) ;; 53 ;; (nav-graph-editor-method-53 (_type_ int int) none 53)
|
|
(nav-graph-editor-method-54 () none) ;; 54 ;; (nav-graph-editor-method-54 (_type_ int) none 54)
|
|
(nav-graph-editor-method-55 () none) ;; 55 ;; (nav-graph-editor-method-55 (_type_ int) none 55)
|
|
(nav-graph-editor-method-56 () none) ;; 56 ;; (nav-graph-editor-method-56 (_type_ int) none 56)
|
|
(nav-graph-editor-method-57 () none) ;; 57 ;; (nav-graph-editor-method-57 (_type_ int int) int 57)
|
|
(nav-graph-editor-method-58 () none) ;; 58 ;; (nav-graph-editor-method-58 (_type_) symbol 58)
|
|
(nav-graph-editor-method-59 () none) ;; 59 ;; (nav-graph-editor-method-59 (_type_) pad-buttons 59)
|
|
(nav-graph-editor-method-60 () none) ;; 60 ;; (nav-graph-editor-method-60 (_type_) none 60)
|
|
(nav-graph-editor-method-61 () none) ;; 61 ;; (nav-graph-editor-method-61 (_type_) none 61)
|
|
(nav-graph-editor-method-62 () none) ;; 62 ;; (nav-graph-editor-method-62 (_type_ symbol symbol) none 62)
|
|
(nav-graph-editor-method-63 () none) ;; 63 ;; (nav-graph-editor-method-63 (_type_) none 63)
|
|
(nav-graph-editor-method-64 () none) ;; 64
|
|
(nav-graph-editor-method-65 () none) ;; 65
|
|
(nav-graph-editor-method-66 () none) ;; 66
|
|
(nav-graph-editor-method-67 () none) ;; 67
|
|
)
|
|
(:state-methods
|
|
adjust-node-angle ;; 22, old: (adjust-node-angle () _type_ :state 22)
|
|
move-node ;; 14, old: (move-node () _type_ :state 14)
|
|
adjust-plane ;; 19, old: (adjust-plane () _type_ :state 19)
|
|
adjust-node-radius ;; 23, old: (adjust-node-radius () _type_ :state 23)
|
|
move-plane ;; 15, old: (move-plane () _type_ :state 15)
|
|
create-edge ;; 18, old: (create-edge () _type_ :state 18)
|
|
edit-edge ;; 17, old: (edit-edge () _type_ :state 17)
|
|
adjust-edge-visibility ;; 24, old: (adjust-edge-visibility () _type_ :state 24)
|
|
adjust-edge-width ;; 25, old: (adjust-edge-width () _type_ :state 25)
|
|
adjust-edge-density ;; 26, old: (adjust-edge-density () _type_ :state 26)
|
|
adjust-it ;; 20, old: (adjust-it () _type_ :state 20)
|
|
adjust-minimap ;; 21, old: (adjust-minimap () _type_ :state 21)
|
|
draw-closest-minimap ;; 27, old: (draw-closest-minimap () _type_ :state 27)
|
|
create ;; 16, old: (create () _type_ :state 16)
|
|
create-pov ;; 28, old: (nav-graph-editor-method-28 (_type_) none 28)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *nav-graph-editor* object) ;; (pointer nav-graph-editor)
|
|
;; (define-extern get-node-draw-position function)
|
|
;; (define-extern nav-graph-editor-init-by-other function) ;; (function string none :behavior nav-graph-editor)
|
|
;; (define-extern run-nav-graph-editor function) ;; (function symbol (pointer process))
|
|
;; (define-extern get-nav-graph-editor function) ;; (function nav-graph-editor)
|
|
;; (define-extern exit-nav-graph-editor function) ;; (function none)
|
|
;; (define-extern nav-graph-set-level function)
|
|
;; (define-extern set-minimap-edge-flag function) ;; (function nav-minimap-edge-flag uint)
|
|
;; (define-extern set-vehicle-edit-mode function) ;; (function symbol none)
|
|
;; (define-extern translate-nav-graph function) ;; (function float float float symbol)
|
|
;; (define-extern update-nav-meshes function) ;; (function symbol)
|
|
;; (define-extern delete-node-nav-mesh function)
|
|
;; (define-extern smooth-nav-graph function) ;; (function string symbol)
|
|
;; (define-extern update-height function) ;; (function string symbol)
|
|
;; (define-extern update-width function) ;; (function string symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gsf-vertex (structure)
|
|
((data uint32 8 :offset-assert 0) ;; guessed by decompiler
|
|
(byte uint8 32 :offset-assert 0) ;; guessed by decompiler
|
|
(quad uint128 2 :offset-assert 0) ;; guessed by decompiler
|
|
(vt qword :inline :offset-assert 0)
|
|
(pos vector3s :inline :offset-assert 0)
|
|
(tex vector2uh :inline :offset-assert 12)
|
|
(nrm vector3s :inline :offset-assert 16)
|
|
(nc qword :inline :offset-assert 16)
|
|
(clr vector4ub :inline :offset-assert 28)
|
|
(dtex vector2uh :inline :offset-assert 16)
|
|
(dclr vector4ub :inline :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gsf-fx-vertex (structure)
|
|
((clr vector4ub :inline :offset-assert 0)
|
|
(tex vector2uh :inline :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gsf-header (structure)
|
|
((num-strips uint8 :offset-assert 0)
|
|
(num-new-vtxs uint8 :offset-assert 1)
|
|
(num-dps uint16 :offset-assert 2)
|
|
(num-vtxs uint16 :offset-assert 4)
|
|
(strip-table uint8 10 :offset-assert 6) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gsf-ik (structure)
|
|
((index uint8 :offset-assert 0)
|
|
(no-kick uint8 :offset-assert 1)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gsf-info (structure)
|
|
((ptr-iks uint32 :offset-assert 0)
|
|
(ptr-verts uint32 :offset-assert 4)
|
|
(ptr-fx uint32 :offset-assert 8)
|
|
(dummy2 uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gsf-buffer (structure)
|
|
((data uint8 8192 :offset-assert 0) ;; guessed by decompiler
|
|
(info gsf-info :inline :offset-assert 0)
|
|
(header gsf-header :inline :offset-assert 16)
|
|
(work-area uint8 :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2000
|
|
:flag-assert #x900002000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-frag (structure)
|
|
((start-pos uint16 :offset-assert 0)
|
|
(end-pos uint16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-strip (structure)
|
|
((pos uint16 :offset-assert 0)
|
|
(len uint16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-envmap-saves (structure)
|
|
((index-mask vector4w :inline :offset-assert 0)
|
|
(verts uint128 12 :offset-assert 16) ;; guessed by decompiler
|
|
(kicks uint128 4 :offset-assert 208) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x110
|
|
:flag-assert #x900000110
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-interp-job (structure)
|
|
((job-type uint16 :offset-assert 0)
|
|
(num uint16 :offset-assert 2)
|
|
(first uint16 :offset-assert 4)
|
|
(pad uint16 :offset-assert 6)
|
|
(ptr-data uint32 :offset-assert 8)
|
|
(morph-z uint16 :offset-assert 12)
|
|
(morph-w uint16 :offset-assert 14)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-saves (structure)
|
|
((ptr-dma uint32 :offset-assert 0)
|
|
(ptr-vtxs uint32 :offset-assert 4)
|
|
(ptr-clrs uint32 :offset-assert 8)
|
|
(ptr-texs uint32 :offset-assert 12)
|
|
(ptr-env-clrs uint32 :offset-assert 16)
|
|
(ptr-env-texs uint32 :offset-assert 20)
|
|
(cur-outbuf uint32 :offset-assert 24)
|
|
(ptr-fx-buf uint32 :offset-assert 28)
|
|
(xor-outbufs uint32 :offset-assert 32)
|
|
(num-dps uint32 :offset-assert 36)
|
|
(qwc uint32 :offset-assert 40)
|
|
(gsf-buf gsf-buffer :offset-assert 44)
|
|
(ptr-shaders uint32 :offset-assert 48)
|
|
(ptr-env-shader uint32 :offset-assert 52)
|
|
(is-envmap uint16 :offset-assert 56)
|
|
(is-translucent uint16 :offset-assert 58)
|
|
(basep uint32 :offset-assert 60)
|
|
(ptr-interp-job generic-interp-job :offset-assert 64)
|
|
(gifbuf-adr uint32 :offset-assert 68)
|
|
(inbuf-adr uint32 :offset-assert 72)
|
|
(fade-val uint32 :offset-assert 76)
|
|
(time-of-day-color rgba :offset-assert 80) ;; guessed by decompiler
|
|
(to-vu0-waits uint32 :offset-assert 84)
|
|
(to-spr-waits uint32 :offset-assert 88)
|
|
(from-spr-waits uint32 :offset-assert 92)
|
|
(envmap generic-envmap-saves :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x170
|
|
:flag-assert #x900000170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-gif-tag (structure)
|
|
((data uint32 4 :offset-assert 0) ;; guessed by decompiler
|
|
(qword qword :inline :offset-assert 0)
|
|
(fan-prim gif-tag-prim :offset-assert 0) ;; guessed by decompiler
|
|
(str-prim gif-tag-prim :offset-assert 4) ;; guessed by decompiler
|
|
(regs gif-tag-regs-32 :offset-assert 8) ;; guessed by decompiler
|
|
(num-strips uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-envmap-consts (structure)
|
|
((consts vector :inline :offset-assert 0)
|
|
(strgif generic-gif-tag :inline :offset-assert 16)
|
|
(colors vector4w :inline :offset-assert 32)
|
|
(shader adgif-shader :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-consts (structure)
|
|
((dma-header dma-packet :inline :offset-assert 0)
|
|
(vif-header uint32 4 :offset-assert 16) ;; guessed by decompiler
|
|
(dma-ref-vtxs dma-packet :inline :offset-assert 32)
|
|
(dma-cnt-call dma-packet :inline :offset-assert 48)
|
|
(matrix matrix :inline :offset-assert 64)
|
|
(base-strgif generic-gif-tag :inline :offset-assert 128)
|
|
(alpha-opaque gs-adcmd :inline :offset-assert 144)
|
|
(alpha-translucent gs-adcmd :inline :offset-assert 160)
|
|
(ztest-normal gs-adcmd :inline :offset-assert 176)
|
|
(ztest-opaque gs-adcmd :inline :offset-assert 192)
|
|
(adcmd-offsets uint8 16 :offset-assert 208) ;; guessed by decompiler
|
|
(adcmds UNKNOWN 4 :offset-assert 144)
|
|
(stcycle-tag uint32 :offset-assert 224)
|
|
(unpack-vtx-tag uint32 :offset-assert 228)
|
|
(unpack-clr-tag uint32 :offset-assert 232)
|
|
(unpack-tex-tag uint32 :offset-assert 236)
|
|
(mscal-tag uint32 :offset-assert 240)
|
|
(flush-tag uint32 :offset-assert 244)
|
|
(reset-cycle-tag uint32 :offset-assert 248)
|
|
(dummy0 uint32 :offset-assert 252)
|
|
(dma-tag-cnt uint64 :offset-assert 256)
|
|
(envmap generic-envmap-consts :inline :offset-assert 272)
|
|
(light-consts vector :inline :offset-assert 400)
|
|
(texture-offset uint16 8 :offset-assert 416) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1b0
|
|
:flag-assert #x9000001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-storage (structure)
|
|
((data uint128 16 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x100
|
|
:flag-assert #x900000100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gsf-vertex-array (UNKNOWN)
|
|
((vtx gsf-vertex :dynamic :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gsf-fx-vertex-array (UNKNOWN)
|
|
((data gsf-fx-vertex :dynamic :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *gsf-buffer* object) ;; gsf-buffer
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-trans-tables ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ocean-left-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-right-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-up-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-down-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-down-left-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-down-right-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-up-right-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-up-left-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-left-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-right-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-up-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-down-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-down-left-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-down-right-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-up-right-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-up-left-table* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-corner-table* object) ;; (inline-array vector4w-2)
|
|
;; (define-extern *ocean-trans-strip-array* object) ;; (pointer float)
|
|
;; (define-extern *ocean-trans-st-table* object) ;; (inline-array vector)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-func ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern raw-ray-sphere-intersect function)
|
|
;; (define-extern ray-sphere-intersect function) ;; (function vector vector vector float float)
|
|
;; (define-extern ray-circle-intersect function) ;; (function vector vector vector float float)
|
|
;; (define-extern ray-cylinder-intersect function) ;; (function vector vector vector vector float float vector float)
|
|
;; (define-extern ray-plane-intersect function) ;; (function vector vector vector vector vector vector vector float)
|
|
;; (define-extern ray-triangle-intersect function)
|
|
;; (define-extern collide-do-primitives function)
|
|
;; (define-extern moving-sphere-triangle-intersect function) ;; (function vector vector float collide-cache-tri vector vector float)
|
|
;; (define-extern moving-sphere-sphere-intersect function)
|
|
;; (define-extern moving-sphere-moving-sphere-intersect function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-frames ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ocean-wave-frames* object) ;; (pointer uint32)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precurd-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pre-tformer (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wall-window-big (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precurd-door-a (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-bridge-path-break (process-drawable)
|
|
((triggered? basic :offset-assert 196)
|
|
(idx uint8 :offset-assert 200)
|
|
(l-origin matrix :inline :offset-assert 204)
|
|
(actor-group uint32 :offset-assert 268)
|
|
(actor-group-count int32 :offset-assert 272)
|
|
(anim-1-time uint64 :offset-assert 276)
|
|
(delay-time uint64 :offset-assert 284)
|
|
(debris-handle uint64 :offset-assert 292)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #x130
|
|
:flag-assert #x1c00b00130
|
|
(:methods
|
|
(precur-bridge-path-break-method-21 () none) ;; 21
|
|
(precur-bridge-path-break-method-22 () none) ;; 22
|
|
(precur-bridge-path-break-method-23 () none) ;; 23
|
|
(precur-bridge-path-break-method-24 () none) ;; 24
|
|
(precur-bridge-path-break-method-25 () none) ;; 25
|
|
(precur-bridge-path-break-method-26 () none) ;; 26
|
|
(precur-bridge-path-break-method-27 () none) ;; 27
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-bridge-blocks-break (process-drawable)
|
|
((triggered? basic :offset-assert 200)
|
|
(idx uint8 :offset-assert 204)
|
|
(snds UNKNOWN 5 :offset-assert 208)
|
|
(toe-up? UNKNOWN 5 :offset-assert 228)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xf8
|
|
:flag-assert #x1a008000f8
|
|
(:methods
|
|
(precur-bridge-blocks-break-method-21 () none) ;; 21
|
|
(precur-bridge-blocks-break-method-22 () none) ;; 22
|
|
(precur-bridge-blocks-break-method-23 () none) ;; 23
|
|
(precur-bridge-blocks-break-method-24 () none) ;; 24
|
|
(precur-bridge-blocks-break-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern pre-tformer-spawn-leg-a function)
|
|
;; (define-extern pre-tformer-spawn-leg-b function)
|
|
;; (define-extern pre-tformer-spawn-leg-c function)
|
|
;; (define-extern pre-tformer-spawn-spike function)
|
|
;; (define-extern *precurd-obs-shake-time* object)
|
|
;; (define-extern wall-window-big-init-by-other function)
|
|
;; (define-extern *precur-blocks-trigger-points* array)
|
|
;; (define-extern *precur-path-trigger-points* array)
|
|
;; (define-extern *precur-path-2nd-trigger-points* array)
|
|
;; (define-extern *precur-trigger-idx* object)
|
|
;; (define-extern precur-bridge-reset function)
|
|
;; (define-extern precur-bridge-path-trigger function)
|
|
;; (define-extern precur-bridge-path-2nd-trigger function)
|
|
;; (define-extern precur-bridge-blocks-trigger function)
|
|
;; (define-extern precur-trigger-update function)
|
|
;; (define-extern *precur-path-delay-time* array)
|
|
;; (define-extern *precurd-blow-snd-id* object)
|
|
;; (define-extern precur-play-blow-sound function)
|
|
;; (define-extern precur-stop-blow-sound function)
|
|
;; (define-extern *precurd-panel-tear-off-time* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-swim ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern target-swim-tilt function) ;; (function float float float float float :behavior target)
|
|
;; (define-extern target-swim-stance object) ;; (state target)
|
|
;; (define-extern target-swim-walk object) ;; (state target)
|
|
;; (define-extern target-swim-down object) ;; (state target)
|
|
;; (define-extern target-swim-up object) ;; (state target)
|
|
;; (define-extern target-swim-jump-jump object) ;; (state float float surface target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; art-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype joint-anim (basic)
|
|
((name string :offset-assert 4) ;; guessed by decompiler
|
|
(number int16 :offset-assert 8)
|
|
(length int16 :offset-assert 10)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; (deftype joint-anim-matrix (joint-anim)
|
|
;; ()
|
|
;; :flag-assert #x900000010
|
|
;; )
|
|
|
|
#|
|
|
(deftype joint-anim-transformq (joint-anim)
|
|
((name string :offset-assert 0) ;; guessed by decompiler
|
|
(number int16 :offset-assert 4)
|
|
(length int16 :offset-assert 6)
|
|
(data transformq :dynamic :offset-assert 12) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-anim-drawable (joint-anim)
|
|
((data drawable :dynamic :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-anim-frame (structure)
|
|
((matrices matrix 2 :offset-assert 0) ;; guessed by decompiler
|
|
(data transformq :dynamic :offset-assert 128) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-anim-compressed-hdr (structure)
|
|
((control-bits uint32 14 :offset-assert 0) ;; guessed by decompiler
|
|
(num-joints uint32 :offset-assert 56)
|
|
(matrix-bits uint32 :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-anim-compressed-fixed (structure)
|
|
((hdr joint-anim-compressed-hdr :inline :offset-assert 0)
|
|
(offset-64 uint32 :offset-assert 64)
|
|
(offset-32 uint32 :offset-assert 68)
|
|
(offset-16 uint32 :offset-assert 72)
|
|
(reserved uint32 :offset-assert 76)
|
|
(data vector 133 :offset-assert 80) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8a0
|
|
:flag-assert #x9000008a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-anim-compressed-frame (structure)
|
|
((offset-64 uint32 :offset-assert 0)
|
|
(offset-32 uint32 :offset-assert 4)
|
|
(offset-16 uint32 :offset-assert 8)
|
|
(reserved uint32 :offset-assert 12)
|
|
(data vector 133 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x860
|
|
:flag-assert #x900000860
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-anim-compressed-control (structure)
|
|
((num-frames uint16 :offset-assert 0)
|
|
(flags uint16 :offset-assert 2)
|
|
(fixed-qwc uint32 :offset-assert 4)
|
|
(frame-qwc uint32 :offset-assert 8)
|
|
(fixed joint-anim-compressed-fixed :offset-assert 12)
|
|
(data joint-anim-compressed-frame :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype art (basic)
|
|
((name string :offset-assert 8) ;; guessed by decompiler
|
|
(length int32 :offset-assert 12)
|
|
(extra res-lump :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x14
|
|
:flag-assert #xe00000014
|
|
(:methods
|
|
(art-method-9 () none) ;; 9 ;; (login (_type_) _type_ 9)
|
|
(art-method-10 () none) ;; 10 ;; (get-art-by-name-method (_type_ string type) basic 10)
|
|
(art-method-11 () none) ;; 11 ;; (get-art-idx-by-name-method (_type_ string type) int 11)
|
|
(art-method-12 () none) ;; 12 ;; (needs-link? (_type_) symbol 12)
|
|
(art-method-13 () none) ;; 13
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype art-element (art)
|
|
((master-art-group-name basic :offset-assert 20)
|
|
(master-art-group-index int32 :offset-assert 24)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x30
|
|
:flag-assert #xe00000030
|
|
)
|
|
|#
|
|
|
|
;; (deftype art-mesh-anim (art-element)
|
|
;; ()
|
|
;; :flag-assert #xe00000030
|
|
;; )
|
|
|
|
#|
|
|
(deftype art-joint-anim (art-element)
|
|
((eye-anim merc-eye-anim-block :offset-assert 28)
|
|
(blend-shape-anim (pointer int8) :offset-assert 32) ;; guessed by decompiler
|
|
(frames joint-anim-compressed-control :offset-assert 36)
|
|
(speed float :offset-assert 48)
|
|
(artist-base float :offset-assert 52)
|
|
(artist-step float :offset-assert 56)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x3c
|
|
:flag-assert #xe0000003c
|
|
;; field blend-shape-anim uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
;; (deftype art-group (art)
|
|
;; ()
|
|
;; :flag-assert #x1000000020
|
|
;; )
|
|
|
|
;; (deftype art-mesh-geo (art-element)
|
|
;; ()
|
|
;; :flag-assert #xe00000030
|
|
;; )
|
|
|
|
;; (deftype art-joint-geo (art-element)
|
|
;; ()
|
|
;; :flag-assert #xe00000030
|
|
;; )
|
|
|
|
#|
|
|
(deftype art-cloth-geo (art-element)
|
|
((anchor-transforms basic :offset-assert 48)
|
|
(sphere-transforms basic :offset-assert 52)
|
|
(disc-transforms basic :offset-assert 56)
|
|
(cloth-thickness basic :offset-assert 60)
|
|
(thickness-scalar float :offset-assert 64)
|
|
(num-points int32 :offset-assert 12)
|
|
(mesh UNKNOWN :dynamic :offset-assert 80)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x50
|
|
:flag-assert #xe00000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype art-joint-anim-manager-slot (structure)
|
|
((anim art-joint-anim :offset-assert 0) ;; guessed by decompiler
|
|
(comp-data uint32 :offset-assert 4)
|
|
(time-stamp uint64 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype art-joint-anim-manager (basic)
|
|
((heap kheap :inline :offset-assert 16)
|
|
(free-index int32 :offset-assert 32)
|
|
(slot art-joint-anim-manager-slot 64 :offset-assert 48) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x430
|
|
:flag-assert #xe00000430
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(art-joint-anim-manager-method-9 () none) ;; 9 ;; (decompress (_type_ art-joint-anim) art-joint-anim 9)
|
|
(art-joint-anim-manager-method-10 () none) ;; 10 ;; (update-time-stamp (_type_ art-joint-anim) art-joint-anim 10)
|
|
(art-joint-anim-manager-method-11 () none) ;; 11 ;; (unload-from-slot (_type_ int) art-joint-anim 11)
|
|
(art-joint-anim-manager-method-12 () none) ;; 12 ;; (used-bytes-for-slot (_type_ int) int 12)
|
|
(art-joint-anim-manager-method-13 () none) ;; 13 ;; (unload-from-level (_type_ level) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype skeleton-group (art-group)
|
|
((name string :offset-assert 8) ;; guessed by decompiler
|
|
(length int32 :offset-assert 12)
|
|
(extra res-lump :offset-assert 16) ;; guessed by decompiler
|
|
(info file-info :offset-assert 4) ;; guessed by decompiler
|
|
(data art-element :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
(art-group-name string :offset-assert 32) ;; guessed by decompiler
|
|
(jgeo int16 :offset-assert 36) ;; int32
|
|
(janim int16 :offset-assert 38) ;; int32
|
|
(bounds vector :inline :offset-assert 48)
|
|
(radius meters :offset-assert 60)
|
|
(mgeo int16 6 :offset-assert 64) ;; guessed by decompiler
|
|
(max-lod int32 :offset-assert 76)
|
|
(lod-dist float 6 :offset-assert 80) ;; guessed by decompiler
|
|
(longest-edge meters :offset-assert 104)
|
|
(texture-level int8 :offset-assert 108)
|
|
(version int8 :offset-assert 109)
|
|
(shadow int16 :offset-assert 110) ;; int8
|
|
(shadow-joint-index int8 :offset-assert 112)
|
|
(origin-joint-index int8 :offset-assert 113)
|
|
(sort int8 :offset-assert 114)
|
|
(light-index uint8 :offset-assert 115)
|
|
(clothing basic :offset-assert 116)
|
|
(global-effects uint8 :offset-assert 120)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x79
|
|
:flag-assert #x1100000079
|
|
(:methods
|
|
(skeleton-group-method-16 () none) ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lod-group (structure)
|
|
((geo merc-ctrl :offset-assert 0) ;; guessed by decompiler
|
|
(dist meters :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lod-set (structure)
|
|
((lod lod-group 6 :offset-assert 0) ;; guessed by decompiler
|
|
(max-lod int8 :offset-assert 48)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x31
|
|
:flag-assert #xa00000031
|
|
(:methods
|
|
(lod-set-method-9 () none) ;; 9 ;; (setup-lods! (_type_ skeleton-group art-group entity) _type_ 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype draw-control (basic)
|
|
((process process-drawable :offset-assert 4) ;; guessed by decompiler
|
|
(status draw-control-status :offset-assert 8)
|
|
(data-format uint8 :offset-assert 10) ;; draw-control-data-format
|
|
(global-effect draw-control-global-effect :offset-assert 11)
|
|
(art-group art-group :offset-assert 12) ;; guessed by decompiler
|
|
(jgeo art-joint-geo :offset-assert 16) ;; guessed by decompiler
|
|
(mgeo merc-ctrl :offset-assert 20) ;; guessed by decompiler
|
|
(dma-add-func (function process-drawable draw-control symbol object none) :offset-assert 24) ;; guessed by decompiler
|
|
(skeleton skeleton :offset-assert 28) ;; guessed by decompiler
|
|
(lod-set lod-set :inline :offset-assert 32)
|
|
(lod UNKNOWN 6 :offset-assert 32)
|
|
(max-lod int8 :offset-assert 80)
|
|
(force-lod int8 :offset-assert 81)
|
|
(cur-lod int8 :offset-assert 82)
|
|
(desired-lod int8 :offset-assert 83)
|
|
(ripple ripple-control :offset-assert 84) ;; guessed by decompiler
|
|
(longest-edge meters :offset-assert 88)
|
|
(longest-edge? uint32 :offset-assert 88)
|
|
(light-index uint8 :offset-assert 92)
|
|
(shadow-mask uint8 :offset-assert 93)
|
|
(level-index uint8 :offset-assert 94)
|
|
(death-draw-overlap uint8 :offset-assert 95)
|
|
(death-timer uint8 :offset-assert 96)
|
|
(death-timer-org uint8 :offset-assert 97)
|
|
(death-vertex-skip uint16 :offset-assert 98)
|
|
(death-effect uint32 :offset-assert 100)
|
|
(shadow shadow-geo :offset-assert 104) ;; guessed by decompiler
|
|
(shadow-ctrl shadow-control :offset-assert 108) ;; guessed by decompiler
|
|
(distance meters :offset-assert 112)
|
|
(origin vector :inline :offset-assert 128)
|
|
(bounds vector :inline :offset-assert 144)
|
|
(radius meters :offset-assert 156)
|
|
(color-mult rgbaf :inline :offset-assert 160)
|
|
(color-emissive rgbaf :inline :offset-assert 176)
|
|
(effect-mask uint64 :offset-assert 192)
|
|
(seg-mask uint64 :offset-assert 200)
|
|
(origin-joint-index uint8 :offset-assert 208)
|
|
(shadow-joint-index uint8 :offset-assert 209)
|
|
(force-fade uint8 :offset-assert 210)
|
|
(default-texture-page uint8 :offset-assert 211)
|
|
(shadow-values uint32 :offset-assert 212)
|
|
(cloth-instances basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xdc
|
|
:flag-assert #x10000000dc
|
|
;; field draw-control-status is likely a value type. field draw-control-global-effect is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type process symbol) _type_ 0)
|
|
(draw-control-method-9 () none) ;; 9 ;; (get-skeleton-origin (_type_) vector 9)
|
|
(draw-control-method-10 () none) ;; 10 ;; (lod-set! (_type_ int) none 10)
|
|
(draw-control-method-11 () none) ;; 11 ;; (lods-assign! (_type_ lod-set) none 11)
|
|
(draw-control-method-12 () none) ;; 12 ;; (setup-masks (_type_ int int) none 12)
|
|
(draw-control-method-13 () none) ;; 13 ;; (setup-cspace-and-add (_type_ art-joint-geo symbol) cspace-array 13)
|
|
(draw-control-method-14 () none) ;; 14 ;; (do-joint-math (_type_ cspace-array joint-control) none 14)
|
|
(draw-control-method-15 () none) ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-layout ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cam-layout-bank (basic)
|
|
((spline-t float :offset-assert 4)
|
|
(spline-step float :offset-assert 8)
|
|
(intro-t float :offset-assert 12)
|
|
(intro-step float :offset-assert 16)
|
|
(debug-t float :offset-assert 20)
|
|
(debug-step float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clm-basic (basic)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clm-item-action (structure)
|
|
((button uint64 :offset-assert 0)
|
|
(options uint64 :offset-assert 8)
|
|
(func symbol :offset-assert 16) ;; guessed by decompiler
|
|
(parm0 int32 :offset-assert 20) ;; guessed by decompiler
|
|
(parm1 symbol :offset-assert 24) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
;; field parm0 uses ~A with a signed load. field parm1 uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clm-item (clm-basic)
|
|
((description string :offset-assert 4) ;; guessed by decompiler
|
|
(button-symbol symbol :offset-assert 8) ;; guessed by decompiler
|
|
(action clm-item-action :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clm-list-item (basic)
|
|
((description string :offset-assert 4) ;; guessed by decompiler
|
|
(track-val symbol :offset-assert 8) ;; guessed by decompiler
|
|
(val-func symbol :offset-assert 12) ;; guessed by decompiler
|
|
(val-parm0 int32 :offset-assert 16) ;; guessed by decompiler
|
|
(val-parm1 symbol :offset-assert 20) ;; guessed by decompiler
|
|
(actions (array clm-item-action) :offset-assert 24) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
;; field track-val uses ~A with a signed load. field val-parm0 uses ~A with a signed load. field val-parm1 uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clm-list (clm-basic)
|
|
((tracker symbol :offset-assert 4) ;; guessed by decompiler
|
|
(cur-list-item int32 :offset-assert 8)
|
|
(items (array clm-list-item) :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clm (basic)
|
|
((title string :offset-assert 4) ;; guessed by decompiler
|
|
(items (array clm-basic) :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype volume-descriptor-array (inline-array-class)
|
|
((data plane-volume :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-layout (process)
|
|
((cam-entity entity-camera :offset-assert 128) ;; guessed by decompiler
|
|
(num-entities int32 :offset-assert 132)
|
|
(cur-entity int32 :offset-assert 136)
|
|
(num-volumes int32 :offset-assert 140)
|
|
(cur-volume int32 :offset-assert 144)
|
|
(first-pvol int32 :offset-assert 148)
|
|
(first-cutoutvol int32 :offset-assert 152)
|
|
(res-key float :offset-assert 156)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #xa0
|
|
:flag-assert #xe002000a0
|
|
(:states
|
|
cam-layout-active ;; associated process guessed by decompiler, old: (state cam-layout)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype interp-test-info (structure)
|
|
((from vector :inline :offset-assert 0)
|
|
(to vector :inline :offset-assert 16)
|
|
(origin vector :inline :offset-assert 32)
|
|
(color vector4w :offset-assert 48)
|
|
(axis vector :offset-assert 52)
|
|
(disp string :offset-assert 56) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype clmf-cam-flag-toggle-info (structure)
|
|
((key float :offset-assert 0)
|
|
(force-on int32 :offset-assert 4)
|
|
(force-off int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *camera-layout-blink* object) ;; symbol
|
|
;; (define-extern *CAM_LAYOUT-bank* cam-layout-bank) ;; cam-layout-bank
|
|
;; (define-extern *camera-layout-message-ypos* object) ;; int
|
|
;; (define-extern *volume-point-current* object) ;; int
|
|
;; (define-extern *volume-point* object) ;; vector-array
|
|
;; (define-extern *volume-normal-current* object) ;; int
|
|
;; (define-extern *volume-normal* object) ;; vector-array
|
|
;; (define-extern *volume-descriptor-current* object) ;; int
|
|
;; (define-extern *volume-descriptor* object) ;; vol-control
|
|
;; (define-extern cam-layout-print function) ;; (function int int string pointer)
|
|
;; (define-extern cam-layout-intersect-dist function) ;; (function vector vector vector float)
|
|
;; (define-extern cam-layout-entity-volume-info-create function) ;; (function entity-camera symbol symbol :behavior cam-layout)
|
|
;; (define-extern cam-layout-entity-volume-info function) ;; (function symbol :behavior cam-layout)
|
|
;; (define-extern v-slrp! function) ;; (function vector vector vector float vector)
|
|
;; (define-extern interp-test function) ;; (function (function vector vector vector float vector float none) interp-test-info none)
|
|
;; (define-extern interp-test-deg function) ;; (function (function vector vector vector vector float none) interp-test-info none)
|
|
;; (define-extern cam-layout-entity-info function) ;; (function entity-actor none)
|
|
;; (define-extern clmf-button-test function) ;; (function symbol)
|
|
;; (define-extern clmf-bna function) ;; (function symbol)
|
|
;; (define-extern clmf-implement function) ;; (function symbol)
|
|
;; (define-extern clmf-input function) ;; (function vector vector int vector)
|
|
;; (define-extern clmf-pos-rot function) ;; (function symbol symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-next-volume function) ;; (function int symbol :behavior cam-layout)
|
|
;; (define-extern clmf-next-vol-dpad function) ;; (function symbol)
|
|
;; (define-extern clmf-to-edit-cam function) ;; (function symbol)
|
|
;; (define-extern *last-cur-entity* object) ;; int
|
|
;; (define-extern clmf-next-entity function) ;; (function int symbol :behavior cam-layout)
|
|
;; (define-extern clmf-to-spline-attr function) ;; (function symbol)
|
|
;; (define-extern clmf-to-intro-attr function) ;; (function symbol)
|
|
;; (define-extern clmf-to-index-attr function) ;; (function symbol)
|
|
;; (define-extern clmf-to-focalpull-attr function) ;; (function symbol)
|
|
;; (define-extern clmf-to-edit function) ;; (function symbol :behavior cam-layout)
|
|
;; (define-extern clmf-to-select function) ;; (function symbol)
|
|
;; (define-extern clmf-look-through function) ;; (function symbol :behavior cam-layout)
|
|
;; (define-extern fov->maya function) ;; (function float float)
|
|
;; (define-extern cam-layout-save-cam-rot function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-cam-trans function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-pivot function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-align function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-interesting function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-fov function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-focalpull function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-flags function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-focalpull-flags function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-campoints-flags function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-introsplinetime function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-introsplineexitval function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-interptime function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-splineoffset function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-spline-follow-dist-offset function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-campointsoffset function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-tiltAdjust function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-stringMinLength function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-stringMaxLength function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-stringMinHeight function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-stringMaxHeight function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-stringCliffHeight function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern cam-layout-save-maxAngle function) ;; (function symbol string entity-actor none)
|
|
;; (define-extern clmf-save-single function) ;; (function entity-camera symbol symbol file-stream :behavior cam-layout)
|
|
;; (define-extern clmf-save-one function) ;; (function symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-save-all function) ;; (function symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-flag-toggle function) ;; (function int int symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-flag function) ;; (function string uint uint symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-float-adjust function) ;; (function symbol (pointer float) symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-meters function) ;; (function meters symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-fov function) ;; (function degrees symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-deg function) ;; (function degrees symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-intro-time function) ;; (function float symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-interp-time function) ;; (function float symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-float function) ;; (function float symbol symbol :behavior cam-layout)
|
|
;; (define-extern clmf-cam-string function) ;; (function string symbol symbol :behavior cam-layout)
|
|
;; (define-extern *clm-focalpull-attr* clm) ;; clm
|
|
;; (define-extern *clm-index-attr* clm) ;; clm
|
|
;; (define-extern *clm-intro-attr* clm) ;; clm
|
|
;; (define-extern *clm-spline-attr* clm) ;; clm
|
|
;; (define-extern *clm-cam-attr* clm) ;; clm
|
|
;; (define-extern *clm-cam-lookthrough* clm) ;; clm
|
|
;; (define-extern *clm-edit* clm) ;; clm
|
|
;; (define-extern *clm-save-all* clm) ;; clm
|
|
;; (define-extern *clm-save-one* clm) ;; clm
|
|
;; (define-extern *clm-select* clm) ;; clm
|
|
;; (define-extern *clm* object) ;; clm
|
|
;; (define-extern cam-layout-do-action function) ;; (function clm-item-action symbol :behavior cam-layout)
|
|
;; (define-extern cam-layout-function-call function) ;; (function symbol string int basic symbol :behavior cam-layout)
|
|
;; (define-extern cam-layout-do-menu function) ;; (function clm symbol :behavior cam-layout)
|
|
;; (define-extern cam-layout-init function) ;; (function object :behavior cam-layout)
|
|
;; (define-extern cam-layout-stop function) ;; (function symbol)
|
|
;; (define-extern cam-layout-start function) ;; (function symbol)
|
|
;; (define-extern cam-layout-restart function) ;; (function symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; glider-ring-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *hanga-sprite-texture-anim-array* texture-anim-array)
|
|
;; (define-extern cloud-shadow-find-ground function)
|
|
;; (define-extern birth-func-fader function)
|
|
;; (define-extern sparticle-fader function)
|
|
;; (define-extern sparticle-cloud-update function)
|
|
;; (define-extern sparticle-shadow-update function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; merc-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ripple-merc-query (inline-array-class)
|
|
((start-vertex int32 :offset-assert 16)
|
|
(vertex-skip int32 :offset-assert 20)
|
|
(vertex-count int32 :offset-assert 24)
|
|
(current-loc int32 :offset-assert 28)
|
|
(data vector :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x20
|
|
:flag-assert #xe00000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-byte-header (structure)
|
|
((srcdest-off uint8 :offset-assert 0)
|
|
(rgba-off uint8 :offset-assert 1)
|
|
(lump-off uint8 :offset-assert 2)
|
|
(fp-off uint8 :offset-assert 3)
|
|
(mat1-cnt uint8 :offset-assert 4)
|
|
(mat2-cnt uint8 :offset-assert 5)
|
|
(mat3-cnt uint8 :offset-assert 6)
|
|
(samecopy-cnt uint8 :offset-assert 7)
|
|
(crosscopy-cnt uint8 :offset-assert 8)
|
|
(strip-len uint8 :offset-assert 9)
|
|
(mm-quadword-fp-off uint8 :offset-assert 10)
|
|
(mm-quadword-size uint8 :offset-assert 11)
|
|
(perc-off uint8 :offset-assert 12)
|
|
(mat-slot uint8 10 :offset-assert 13) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x17
|
|
:flag-assert #x900000017
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-fragment (structure)
|
|
((header merc-byte-header :inline :offset-assert 0)
|
|
(rest uint8 1 :offset-assert 23) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x18
|
|
:flag-assert #xa00000018
|
|
(:methods
|
|
(merc-fragment-method-9 () none) ;; 9 ;; (login-adgifs (_type_) merc-fragment 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-vtx (structure)
|
|
((mat-0 uint8 :offset-assert 0)
|
|
(mat-1 uint8 :offset-assert 1)
|
|
(nrm-x uint8 :offset-assert 2)
|
|
(pos-x uint8 :offset-assert 3)
|
|
(dst-0 uint8 :offset-assert 4)
|
|
(dst-1 uint8 :offset-assert 5)
|
|
(nrm-y uint8 :offset-assert 6)
|
|
(pos-y uint8 :offset-assert 7)
|
|
(tex-s uint8 :offset-assert 8)
|
|
(tex-t uint8 :offset-assert 9)
|
|
(nrm-z uint8 :offset-assert 10)
|
|
(pos-z uint8 :offset-assert 11)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-fp-header (structure)
|
|
((x-add float :offset-assert 0)
|
|
(y-add float :offset-assert 4)
|
|
(z-add float :offset-assert 8)
|
|
(shader-cnt uint8 :offset-assert 12)
|
|
(kick-info-offset uint8 :offset-assert 13)
|
|
(kick-info-step uint8 :offset-assert 14)
|
|
(hword-cnt uint8 :offset-assert 15)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-mat-dest (structure)
|
|
((matrix-number uint8 :offset-assert 0)
|
|
(matrix-dest uint8 :offset-assert 1)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-fragment-control (structure)
|
|
((unsigned-four-count uint8 :offset-assert 0)
|
|
(lump-four-count uint8 :offset-assert 1)
|
|
(fp-qwc uint8 :offset-assert 2)
|
|
(mat-xfer-count uint8 :offset-assert 3)
|
|
(mat-dest-data merc-mat-dest :dynamic :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-blend-ctrl (structure)
|
|
((blend-vtx-count uint8 :offset-assert 0)
|
|
(nonzero-index-count uint8 :offset-assert 1)
|
|
(bt-index uint8 :dynamic :offset-assert 2) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mei-envmap-tint (structure)
|
|
((fade0 float :offset-assert 0)
|
|
(fade1 float :offset-assert 4)
|
|
(tint rgba :offset-assert 8) ;; guessed by decompiler
|
|
(dummy int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mei-texture-scroll (structure)
|
|
((max-dist float :offset-assert 0)
|
|
(st-int-scale uint8 :offset-assert 4)
|
|
(time-factor uint8 :offset-assert 5)
|
|
(scroll-dir uint8 :offset-assert 6)
|
|
(cached-time uint8 :offset-assert 7)
|
|
(time-delta uint8 :offset-assert 8)
|
|
(dummy uint8 7 :offset-assert 9) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mei-ripple (structure)
|
|
((x-base float :offset-assert 0)
|
|
(z-base float :offset-assert 4)
|
|
(grid-size float :offset-assert 8)
|
|
(angle float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-extra-info (structure)
|
|
((envmap-tint-offset uint8 :offset-assert 0)
|
|
(shader-offset uint8 :offset-assert 1)
|
|
(texture-scroll-offset uint8 :offset-assert 2)
|
|
(ripple-offset uint8 :offset-assert 3)
|
|
(dummy uint8 12 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-effect (structure)
|
|
((frag-geo merc-fragment :offset-assert 0)
|
|
(frag-ctrl merc-fragment-control :offset-assert 4)
|
|
(blend-data merc-blend-data :offset-assert 8)
|
|
(blend-ctrl merc-blend-ctrl :offset-assert 12)
|
|
(merc-effect-version uint8 :offset-assert 16)
|
|
(effect-bits uint8 :offset-assert 17) ;; effect-bits
|
|
(frag-count uint16 :offset-assert 18)
|
|
(blend-frag-count uint16 :offset-assert 20)
|
|
(tri-count uint16 :offset-assert 22)
|
|
(dvert-count uint16 :offset-assert 24)
|
|
(texture-index uint8 :offset-assert 26)
|
|
(effect-usage uint8 :offset-assert 27)
|
|
(extra-info merc-extra-info :offset-assert 28)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x20
|
|
:flag-assert #xa00000020
|
|
(:methods
|
|
(merc-effect-method-9 () none) ;; 9 ;; (login-adgifs (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-eye-ctrl (structure)
|
|
((eye-slot int8 :offset-assert 0)
|
|
(shader-offset int8 :offset-assert 1)
|
|
(shader-count int8 :offset-assert 2)
|
|
(eye-ctrl-index int8 :offset-assert 3)
|
|
(shader adgif-shader 6 :offset-assert 16) ;; guessed by decompiler
|
|
(left-iris-shader adgif-shader :inline :offset-assert 16)
|
|
(left-pupil-shader adgif-shader :inline :offset-assert 96)
|
|
(left-lid-shader adgif-shader :inline :offset-assert 176)
|
|
(right-iris-shader adgif-shader :inline :offset-assert 256)
|
|
(right-pupil-shader adgif-shader :inline :offset-assert 336)
|
|
(right-lid-shader adgif-shader :inline :offset-assert 416)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1f0
|
|
:flag-assert #x9000001f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-eye-anim-frame (structure)
|
|
((pupil-trans-x int8 :offset-assert 0)
|
|
(pupil-trans-y int8 :offset-assert 1)
|
|
(blink int8 :offset-assert 2)
|
|
(iris-scale int8 :offset-assert 4)
|
|
(pupil-scale int8 :offset-assert 5)
|
|
(lid-scale int8 :offset-assert 6)
|
|
(dword uint64 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-eye-anim-block (structure)
|
|
((max-frame int16 :offset-assert 0)
|
|
(data merc-eye-anim-frame :dynamic :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-usage-group (structure)
|
|
((data texture-masks 7 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x150
|
|
:flag-assert #x900000150
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-ctrl-header (structure)
|
|
((xyz-scale float :offset-assert 0)
|
|
(st-magic uint32 :offset-assert 4)
|
|
(st-out-a uint32 :offset-assert 8)
|
|
(st-out-b uint32 :offset-assert 12)
|
|
(st-vif-add uint32 :offset-assert 16)
|
|
(st-int-off uint16 :offset-assert 20)
|
|
(st-int-scale uint16 :offset-assert 22)
|
|
(effect-count uint32 :offset-assert 24)
|
|
(blend-target-count uint32 :offset-assert 28)
|
|
(fragment-count uint16 :offset-assert 32)
|
|
(tri-count uint16 :offset-assert 34)
|
|
(matrix-count uint8 :offset-assert 36)
|
|
(shader-count uint8 :offset-assert 37)
|
|
(transform-vertex-count uint16 :offset-assert 38)
|
|
(dvert-count uint16 :offset-assert 40)
|
|
(one-mat-count uint16 :offset-assert 42)
|
|
(two-mat-count uint16 :offset-assert 44)
|
|
(two-mat-reuse-count uint16 :offset-assert 46)
|
|
(three-mat-count uint16 :offset-assert 48)
|
|
(three-mat-reuse-count uint16 :offset-assert 50)
|
|
(shader-upload-count uint8 :offset-assert 52)
|
|
(matrix-upload-count uint8 :offset-assert 53)
|
|
(same-copy-count uint16 :offset-assert 54)
|
|
(cross-copy-count uint16 :offset-assert 56)
|
|
(num-verts uint16 :offset-assert 58)
|
|
(longest-edge float :offset-assert 60)
|
|
(eye-ctrl merc-eye-ctrl :offset-assert 64)
|
|
(pad uint32 3 :offset-assert 68) ;; guessed by decompiler
|
|
(masks-padding texture-masks :inline :offset-assert 80)
|
|
(texture-usage-group texture-usage-group :offset-assert 80)
|
|
(dummy-bytes uint8 :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
(envmap-tint uint32 :offset-assert 32)
|
|
(query basic :offset-assert 36)
|
|
(needs-clip uint8 :offset-assert 40)
|
|
(use-isometric uint8 :offset-assert 41)
|
|
(use-attached-shader uint8 :offset-assert 42)
|
|
(display-triangles uint8 :offset-assert 43)
|
|
(death-vertex-skip uint16 :offset-assert 44)
|
|
(death-start-vertex uint16 :offset-assert 46)
|
|
(death-effect uint32 :offset-assert 48)
|
|
(use-translucent uint8 :offset-assert 52)
|
|
(display-this-fragment uint8 :offset-assert 53)
|
|
(use-warp uint8 :offset-assert 54)
|
|
(ignore-alpha uint8 :offset-assert 55)
|
|
(force-fade uint8 :offset-assert 56)
|
|
(disable-fog uint8 :offset-assert 57)
|
|
(disable-envmap uint8 :offset-assert 58)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
;; field xyz-scale is a float printed as hex?
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-ctrl (art-element)
|
|
((num-joints int32 :offset-assert 12)
|
|
(seg-table (array uint64) :offset-assert 28) ;; guessed by decompiler
|
|
(header merc-ctrl-header :inline :offset-assert 48)
|
|
(effect merc-effect :dynamic :offset-assert 176) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #xb0
|
|
:flag-assert #xe000000b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-vu1-low-mem (structure)
|
|
((tri-strip-gif qword :inline :offset-assert 0) ;; gs-gif-tag :inline
|
|
(ad-gif qword :inline :offset-assert 16) ;; gs-gif-tag :inline
|
|
(hvdf-offset vector :inline :offset-assert 32)
|
|
(perspective uint128 4 :offset-assert 48) ;; guessed by decompiler
|
|
(fog vector :inline :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype emerc-vu1-low-mem (structure)
|
|
((tri-strip-gif qword :inline :offset-assert 0) ;; gs-gif-tag :inline
|
|
(ad-gif qword :inline :offset-assert 16) ;; gs-gif-tag :inline
|
|
(hvdf-offset vector :inline :offset-assert 32)
|
|
(perspective vector 4 :offset-assert 48) ;; guessed by decompiler
|
|
(fog vector :inline :offset-assert 112)
|
|
(unperspect vector :inline :offset-assert 128)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texture-login-data (structure)
|
|
((default-texture-index int32 :offset-assert 0)
|
|
(current-texture-index int32 :offset-assert 4)
|
|
(texture-usage-group texture-usage-group :offset-assert 8)
|
|
(merc-ctrl-header merc-ctrl-header :offset-assert 12)
|
|
(name basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ripple-wave (structure)
|
|
((scale float :offset-assert 0)
|
|
(offs float :offset-assert 4)
|
|
(xdiv int16 :offset-assert 8)
|
|
(zdiv int16 :offset-assert 10)
|
|
(speed float :offset-assert 12)
|
|
(xmul float :offset-assert 16)
|
|
(zmul float :offset-assert 20)
|
|
(delta float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ripple-wave-set (basic)
|
|
((count int32 :offset-assert 4)
|
|
(converted basic :offset-assert 8)
|
|
(normal-scale float :offset-assert 12)
|
|
(wave ripple-wave 4 :offset-assert 16) ;; guessed by decompiler
|
|
(frame-save uint64 :offset-assert 128)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x88
|
|
:flag-assert #x900000088
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ripple-control (basic)
|
|
((global-scale float :offset-assert 4)
|
|
(last-frame-scale float :offset-assert 8)
|
|
(close-fade-dist float :offset-assert 12)
|
|
(far-fade-dist float :offset-assert 16)
|
|
(faded-scale float :offset-assert 20)
|
|
(individual-normal-scale float :offset-assert 24)
|
|
(waveform ripple-wave-set :offset-assert 28) ;; guessed by decompiler
|
|
(send-query symbol :offset-assert 32) ;; guessed by decompiler
|
|
(query ripple-merc-query :offset-assert 36) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype death-info (basic)
|
|
((vertex-skip uint16 :offset-assert 4)
|
|
(timer uint8 :offset-assert 6)
|
|
(overlap uint8 :offset-assert 7)
|
|
(effect uint32 :offset-assert 8)
|
|
(sound symbol :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-blend-data (UNKNOWN)
|
|
((int8-data int8 :dynamic :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern merc-fragment-fp-data function) ;; (function merc-fragment merc-fp-header)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; speech-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype speech-instance (structure)
|
|
((speech uint16 :offset-assert 0)
|
|
(num-play-times int8 :offset-assert 2)
|
|
(probability float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype speech-info (structure)
|
|
((speeches basic :offset-assert 0)
|
|
(flags uint64 :offset-assert 8)
|
|
(play-time uint64 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; (define-extern mark-speech-played function)
|
|
;; (define-extern speech-play function)
|
|
;; (define-extern speeches-reset function)
|
|
;; (define-extern speeches-debug-reset function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-work-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype generic-input-buffer (structure)
|
|
((data uint128 473 :offset-assert 0) ;; guessed by decompiler
|
|
(merc generic-merc-work :inline :offset-assert 0)
|
|
(tie generic-tie-work :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1d90
|
|
:flag-assert #x900001d90
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-debug (structure)
|
|
((locks uint32 4 :offset-assert 0) ;; guessed by decompiler
|
|
(timer uint32 32 :offset-assert 16) ;; guessed by decompiler
|
|
(count uint32 32 :offset-assert 144) ;; guessed by decompiler
|
|
(vps uint32 32 :offset-assert 272) ;; guessed by decompiler
|
|
(buffer int32 :offset-assert 400)
|
|
(start-addr int32 :offset-assert 404)
|
|
(lock int32 :offset-assert 408)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x19c
|
|
:flag-assert #x90000019c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-vu1-header (structure)
|
|
((matrix matrix :inline :offset-assert 0)
|
|
(strgif generic-gif-tag :inline :offset-assert 64)
|
|
(adcmds gs-adcmd 2 :offset-assert 80) ;; guessed by decompiler
|
|
(adnop1 gs-adcmd :inline :offset-assert 80)
|
|
(adnop2 gs-adcmd :inline :offset-assert 96)
|
|
(dps uint16 :offset-assert 92)
|
|
(kickoff uint16 :offset-assert 108)
|
|
(strips uint16 :offset-assert 76)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-vu1-texbuf (structure)
|
|
((header generic-vu1-header :inline :offset-assert 0)
|
|
(shader uint32 :dynamic :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-texbuf (structure)
|
|
((tag dma-packet :inline :offset-assert 0)
|
|
(header generic-vu1-header :inline :offset-assert 16)
|
|
(shader uint32 :dynamic :offset-assert 128) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-effect-work (structure)
|
|
((consts generic-consts :inline :offset-assert 0)
|
|
(storage generic-storage :inline :offset-assert 432)
|
|
(storage2 generic-storage :inline :offset-assert 688)
|
|
(lights vu-lights :inline :offset-assert 944)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x420
|
|
:flag-assert #x900000420
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-effect-buffer (structure)
|
|
((outbuf-0 uint8 3552 :offset-assert 0) ;; guessed by decompiler
|
|
(work generic-effect-work :inline :offset-assert 3552)
|
|
(outbuf-1 uint8 3552 :offset-assert 4608) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1fe0
|
|
:flag-assert #x900001fe0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-work (structure)
|
|
((saves generic-saves :inline :offset-assert 0)
|
|
(storage generic-storage :inline :offset-assert 368)
|
|
(in-buf generic-input-buffer :inline :offset-assert 624)
|
|
(fx-buf generic-effect-buffer :inline :offset-assert 8192)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3fe0
|
|
:flag-assert #x900003fe0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *generic-debug* object) ;; generic-debug
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasdef-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-wascity-defend (task-manager)
|
|
((wascity-defend-entity basic :offset-assert 236)
|
|
(check-timer uint64 :offset-assert 244)
|
|
(actor-group uint32 :offset-assert 252)
|
|
(actor-group-count int32 :offset-assert 256)
|
|
(cur-group int8 :offset-assert 260)
|
|
(facing-city? basic :offset-assert 264)
|
|
(failed basic :offset-assert 268)
|
|
(completed basic :offset-assert 272)
|
|
(miss-count int16 :offset-assert 276)
|
|
(last-miss-count int16 :offset-assert 278)
|
|
(launch-time uint64 :offset-assert 284)
|
|
(win-time uint64 :offset-assert 292)
|
|
(last-hit-time uint64 :offset-assert 300)
|
|
(added-points-time uint64 :offset-assert 308)
|
|
(point-queue int16 :offset-assert 316)
|
|
(skeet-hit int16 :offset-assert 318)
|
|
(shot-count-at-last-hit int16 :offset-assert 320)
|
|
(bonus-mult int16 :offset-assert 322)
|
|
(numshots int16 :offset-assert 324)
|
|
(queue-time int32 :offset-assert 328)
|
|
(event-length uint64 :offset-assert 332)
|
|
(event-time uint64 :offset-assert 340)
|
|
(wave int32 :offset-assert 348)
|
|
(event int32 :offset-assert 352)
|
|
(wct uint64 :offset-assert 356)
|
|
(score int32 :offset-assert 364)
|
|
(hud-score uint64 :offset-assert 372)
|
|
(hud-goal uint64 :offset-assert 380)
|
|
(hud-miss uint64 :offset-assert 388)
|
|
(hud-reticle uint64 :offset-assert 396)
|
|
(hud-damage uint64 :offset-assert 404)
|
|
(hud-active? basic :offset-assert 412)
|
|
(out-of-turret? basic :offset-assert 416)
|
|
(sent-event-complete? basic :offset-assert 420)
|
|
(time-out-of-turret uint64 :offset-assert 428)
|
|
(start-time uint64 :offset-assert 164)
|
|
(alarm uint32 :offset-assert 444)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x1c4
|
|
:flag-assert #x24015001c4
|
|
(:methods
|
|
(task-manager-wascity-defend-method-32 () none) ;; 32
|
|
(task-manager-wascity-defend-method-33 () none) ;; 33
|
|
(task-manager-wascity-defend-method-34 () none) ;; 34
|
|
(task-manager-wascity-defend-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hip-maker-event (structure)
|
|
((event-length uint32 :offset-assert 0)
|
|
(path-idx uint32 :offset-assert 4)
|
|
(mode uint8 :offset-assert 8)
|
|
(angle float :offset-assert 12)
|
|
(speed float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype maker-damage (structure)
|
|
((part basic :offset-assert 0)
|
|
(pos vector :inline :offset-assert 16)
|
|
(jnt uint8 :offset-assert 32)
|
|
(active basic :offset-assert 36)
|
|
(counter uint8 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x29
|
|
:flag-assert #x900000029
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype maker (process-focusable)
|
|
((forw vector :inline :offset-assert 208)
|
|
(ppos vector :inline :offset-assert 224)
|
|
(pvel vector :inline :offset-assert 240)
|
|
(pacc vector :inline :offset-assert 256)
|
|
(speed-mod float :offset-assert 272)
|
|
(tentacle-speed float :offset-assert 276)
|
|
(rot-vel float :offset-assert 280)
|
|
(rot-acc float :offset-assert 284)
|
|
(visible-explode-time uint64 :offset-assert 288)
|
|
(birth-time uint64 :offset-assert 296)
|
|
(footstep-time uint64 :offset-assert 304)
|
|
(last-hit-time uint64 :offset-assert 312)
|
|
(last-fire-time uint64 :offset-assert 320)
|
|
(last-laser-fire-time uint64 :offset-assert 328)
|
|
(audible-explode-time uint64 :offset-assert 336)
|
|
(exploded-time uint64 :offset-assert 344)
|
|
(mult uint8 :offset-assert 352)
|
|
(score uint16 :offset-assert 354)
|
|
(minimap connection-minimap :offset-assert 356)
|
|
(maker-sound uint32 :offset-assert 360)
|
|
(maker-sound-playing? basic :offset-assert 364)
|
|
(explosion-sound-id uint32 :offset-assert 368)
|
|
(made-splash? basic :offset-assert 372)
|
|
(head-rot quaternion :inline :offset-assert 384)
|
|
(head-jm basic :offset-assert 400)
|
|
(head-tilt float :offset-assert 404)
|
|
(head-tilt-vel float :offset-assert 408)
|
|
(head-tilt-err float :offset-assert 412)
|
|
(head-yaw float :offset-assert 416)
|
|
(head-yaw-vel float :offset-assert 420)
|
|
(head-yaw-err float :offset-assert 424)
|
|
(walk-idle-blend float :offset-assert 428)
|
|
(idle-ball-blend float :offset-assert 432)
|
|
(hit-points float :offset-assert 436)
|
|
(num-shots int8 :offset-assert 440)
|
|
(damage-idx int8 :offset-assert 441)
|
|
(wait-time uint32 :offset-assert 444)
|
|
(reticle-on? basic :offset-assert 448)
|
|
(kick-your-ass-count uint8 :offset-assert 452)
|
|
(kick-your-ass-string uint8 :offset-assert 453)
|
|
(prim-targeted int8 :offset-assert 454)
|
|
(damage-info UNKNOWN 5 :offset-assert 464)
|
|
(path-idx int16 :offset-assert 704)
|
|
(path-pt int16 :offset-assert 706)
|
|
(path-len int16 :offset-assert 708)
|
|
(seek-pos vector :inline :offset-assert 720)
|
|
(mode uint8 :offset-assert 736)
|
|
(trail-handle uint64 :offset-assert 744)
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x2f0
|
|
:flag-assert #x2b027002f0
|
|
(:methods
|
|
(maker-method-32 () none) ;; 32
|
|
(maker-method-33 () none) ;; 33
|
|
(maker-method-34 () none) ;; 34
|
|
(maker-method-35 () none) ;; 35
|
|
(maker-method-36 () none) ;; 36
|
|
(maker-method-37 () none) ;; 37
|
|
(maker-method-38 () none) ;; 38
|
|
(maker-method-39 () none) ;; 39
|
|
(maker-method-40 () none) ;; 40
|
|
(maker-method-41 () none) ;; 41
|
|
(maker-method-42 () none) ;; 42
|
|
)
|
|
(:state-methods
|
|
standup ;; 31
|
|
walking ;; 30
|
|
flying ;; 28
|
|
explode ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *maker-num-alive* object)
|
|
;; (define-extern *maker-num-visible* object)
|
|
;; (define-extern *maker-num-grenades* object)
|
|
;; (define-extern *maker-last-shot-time* object)
|
|
;; (define-extern *maker-first-hit* object)
|
|
;; (define-extern *maker-first-kill* object)
|
|
;; (define-extern *maker-first-missile* object)
|
|
;; (define-extern *maker-last-vocalization* object)
|
|
;; (define-extern *wascity-alarm-pos1* object)
|
|
;; (define-extern *wascity-alarm-pos2* object)
|
|
;; (define-extern *wascity-defend-speech-list* object)
|
|
;; (define-extern *maker-debris-params* debris-static-params)
|
|
;; (define-extern *curve-maker-entry-linear-up-red* object)
|
|
;; (define-extern *trail-color-curve-maker-entry* curve-color-fast)
|
|
;; (define-extern *curve-maker-entry-linear-trail* curve2d-fast)
|
|
;; (define-extern *maker-entry-trail* object)
|
|
;; (define-extern *maker-data* array)
|
|
;; (define-extern *maker-rigid-body-constants* object)
|
|
;; (define-extern *maker-damage-joint-array* array)
|
|
;; (define-extern *maker-joint-array* array)
|
|
;; (define-extern maker-world-to-local-vec! function)
|
|
;; (define-extern *say-iteration-counter* object)
|
|
;; (define-extern *say-timestamp* object)
|
|
;; (define-extern wasdef-voiceover function)
|
|
;; (define-extern maker-standard-event-handler function)
|
|
;; (define-extern get-ocean-floor-height function)
|
|
;; (define-extern *maker-close* object)
|
|
;; (define-extern *maker-close-count* object)
|
|
;; (define-extern *maker-traverse-paths* array)
|
|
;; (define-extern maker-init-by-other function)
|
|
;; (define-extern spawn-maker function)
|
|
;; (define-extern *maker-avoid-spheres* array)
|
|
;; (define-extern spawn-maker-enum function)
|
|
;; (define-extern jak-out-of-turret function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; shadow-cpu-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype shadow-settings (structure)
|
|
((center vector :inline :offset-assert 0)
|
|
(flags int32 :offset-assert 12) ;; shadow-flags
|
|
(shadow-dir vector :inline :offset-assert 16)
|
|
(dist-to-locus float :offset-assert 28)
|
|
(bot-plane plane :inline :offset-assert 32)
|
|
(top-plane plane :inline :offset-assert 48)
|
|
(fade-dist float :offset-assert 64)
|
|
(fade-start float :offset-assert 68)
|
|
(dummy-2 int32 :offset-assert 72)
|
|
(shadow-type int32 :offset-assert 76)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-control (basic)
|
|
((settings shadow-settings :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x60
|
|
:flag-assert #xf00000060
|
|
(:methods
|
|
;; (new (symbol type float float float shadow-flags float) _type_ 0)
|
|
(shadow-control-method-9 () none) ;; 9 ;; (enable-draw (shadow-control) int 9)
|
|
(shadow-control-method-10 () none) ;; 10 ;; (disable-draw (shadow-control) int 10)
|
|
(shadow-control-method-11 () none) ;; 11 ;; (set-top-plane-offset (shadow-control float) int 11)
|
|
(shadow-control-method-12 () none) ;; 12 ;; (set-bottom-plane-offset (shadow-control float) int 12)
|
|
(shadow-control-method-13 () none) ;; 13 ;; (probe-line-for-shadow (_type_ vector float float float) none 13)
|
|
(shadow-control-method-14 () none) ;; 14 ;; (shadow-control-method-14 (_type_ vector vector float float float) none 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-data (structure)
|
|
((dma-unpack-template dma-packet :inline :offset-assert 0)
|
|
(dma-cnt uint64 :offset-assert 16) ;; dma-tag
|
|
(vif-nop vif-tag :offset-assert 24) ;; guessed by decompiler
|
|
(vif-unpack-v4-8 vif-tag :offset-assert 28) ;; guessed by decompiler
|
|
(pdc basic :offset-assert 32)
|
|
(dist float :offset-assert 36)
|
|
(waits uint32 :offset-assert 40)
|
|
(inside-volume? uint32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-work (structure)
|
|
((shadow-data shadow-data :inline :offset-assert 0)
|
|
(inbuf uint128 600 :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x25b0
|
|
:flag-assert #x9000025b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-bucket (structure)
|
|
((first pointer :offset-assert 0) ;; guessed by decompiler
|
|
(next pointer :offset-assert 4) ;; guessed by decompiler
|
|
(bucket-id int32 :offset-assert 8)
|
|
(shadow-color rgba :offset-assert 12) ;; guessed by decompiler
|
|
(constants shadow-vu1-constants :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-globals (structure)
|
|
((num-buckets uint32 :offset-assert 0)
|
|
(cur-bucket uint32 :offset-assert 4)
|
|
(bucket shadow-bucket 3 :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x68
|
|
:flag-assert #x900000068
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-vertex (structure)
|
|
((x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(z float :offset-assert 8)
|
|
(weight float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-matrix-ref (structure)
|
|
((joint-0 uint8 :offset-assert 0)
|
|
(joint-1 uint8 :offset-assert 1)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-edge (structure)
|
|
((ind-0 uint8 :offset-assert 0)
|
|
(ind-1 uint8 :offset-assert 1)
|
|
(tri-0 uint8 :offset-assert 2)
|
|
(tri-1 uint8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-tri (structure)
|
|
((ind-0 uint8 :offset-assert 0)
|
|
(ind-1 uint8 :offset-assert 1)
|
|
(ind-2 uint8 :offset-assert 2)
|
|
(faces uint8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-frag-header (structure)
|
|
((qwc-data uint32 :offset-assert 0)
|
|
(num-joints uint32 :offset-assert 4)
|
|
(num-verts uint16 :offset-assert 8)
|
|
(num-twos uint16 :offset-assert 10)
|
|
(num-single-tris uint16 :offset-assert 12)
|
|
(num-single-edges uint16 :offset-assert 14)
|
|
(num-double-tris uint16 :offset-assert 16)
|
|
(num-double-edges uint16 :offset-assert 18)
|
|
(ofs-verts uint32 :offset-assert 20)
|
|
(ofs-refs uint32 :offset-assert 24)
|
|
(ofs-single-tris uint32 :offset-assert 28)
|
|
(ofs-single-edges uint32 :offset-assert 32)
|
|
(ofs-double-tris uint32 :offset-assert 36)
|
|
(ofs-double-edges uint32 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-frag-ref (structure)
|
|
((header shadow-frag-header :offset-assert 0)
|
|
(qwc uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-geo (art-element)
|
|
((version uint32 :offset-assert 28)
|
|
(total-size uint32 :offset-assert 32)
|
|
(total-qwc uint32 :offset-assert 48)
|
|
(num-joints uint32 :offset-assert 52)
|
|
(num-fragments uint32 :offset-assert 56)
|
|
(frags shadow-frag-ref :dynamic :offset-assert 60) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x3c
|
|
:flag-assert #xe0000003c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *shadow-globals* object) ;; shadow-globals
|
|
;; (define-extern *shadow* object) ;; symbol
|
|
;; (define-extern *shadow-object* object) ;; symbol
|
|
;; (define-extern *shadow-debug* object) ;; symbol
|
|
;; (define-extern *shadow-dma-buf* object) ;; dma-buffer
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-death ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype kill-nearby-enemies-info (basic)
|
|
((dist float :offset-assert 4)
|
|
(pos vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *auto-continue* object) ;; symbol
|
|
;; (define-extern next-continue function) ;; (function continue-point continue-point)
|
|
;; (define-extern arrive-at-continue function)
|
|
;; (define-extern apply-pos-from-entity function)
|
|
;; (define-extern target-continue-init-art function)
|
|
;; (define-extern *smack-mods* surface) ;; surface
|
|
;; (define-extern *smack-up-mods* surface) ;; surface
|
|
;; (define-extern velocity-set-to-target! function) ;; (function vector float attack-info vector :behavior target)
|
|
;; (define-extern target-hit-effect function) ;; (function attack-info none :behavior target)
|
|
;; (define-extern target-hit-push function) ;; (function vector matrix float float attack-info symbol :behavior target)
|
|
;; (define-extern target-hit-orient function) ;; (function attack-info vector symbol :behavior target)
|
|
;; (define-extern target-hit-setup-anim function) ;; (function attack-info none :behavior target)
|
|
;; (define-extern target-hit-move function) ;; (function attack-info symbol (function none :behavior target) float none :behavior target)
|
|
;; (define-extern *death-spool-array* array) ;; (array spool-anim)
|
|
;; (define-extern death-movie-remap function) ;; (function int int int)
|
|
;; (define-extern *kill-nearby-enemies-info* kill-nearby-enemies-info) ;; kill-nearby-enemies-info
|
|
;; (define-extern kill-nearby-enemies function) ;; (function vector float object)
|
|
;; (define-extern target-death-anim-trans function) ;; (function none :behavior target)
|
|
;; (define-extern target-death-anim function) ;; (function spool-anim none :behavior target)
|
|
;; (define-extern target-death-main function) ;; (function symbol none :behavior target)
|
|
;; (define-extern target-death-reset function) ;; (function symbol symbol none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; trajectory-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype trajectory (structure)
|
|
((initial-position vector :inline :offset-assert 0)
|
|
(initial-velocity vector :inline :offset-assert 16)
|
|
(time float :offset-assert 32)
|
|
(gravity meters :offset-assert 36)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x28
|
|
:flag-assert #x1200000028
|
|
(:methods
|
|
(trajectory-method-9 () none) ;; 9 ;; (compute-trans-at-time (_type_ float vector) vector 9)
|
|
(trajectory-method-10 () none) ;; 10 ;; (compute-transv-at-time (_type_ float vector) vector 10)
|
|
(trajectory-method-11 () none) ;; 11 ;; (compute-time-until-apex (_type_) float 11)
|
|
(trajectory-method-12 () none) ;; 12 ;; (setup-from-to-duration! (_type_ vector vector float float) none 12)
|
|
(trajectory-method-13 () none) ;; 13 ;; (setup-from-to-xz-vel! (_type_ vector vector float float) none 13)
|
|
(trajectory-method-14 () none) ;; 14 ;; (setup-from-to-y-vel! (_type_ vector vector float float) none 14)
|
|
(trajectory-method-15 () none) ;; 15 ;; (setup-from-to-height! (_type_ vector vector float float) none 15)
|
|
(trajectory-method-16 () none) ;; 16 ;; (setup-from-to-duration-and-height! (_type_ vector vector float float) none 16)
|
|
(trajectory-method-17 () none) ;; 17 ;; (debug-draw (_type_) none 17)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype impact-control (structure)
|
|
((process (pointer process-drawable) :offset-assert 0) ;; guessed by decompiler
|
|
(radius meters :offset-assert 4) ;; float
|
|
(joint int32 :offset-assert 8)
|
|
(collide-with collide-spec :offset-assert 12) ;; guessed by decompiler
|
|
(start-time uint64 :offset-assert 16) ;; time-frame
|
|
(trans vector 2 :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(dir vector :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x50
|
|
:flag-assert #xc00000050
|
|
(:methods
|
|
;; (new (symbol type process-drawable int float collide-spec) _type_ 0)
|
|
(impact-control-method-9 () none) ;; 9 ;; (initialize (_type_ process-drawable int float collide-spec) impact-control 9)
|
|
(impact-control-method-10 () none) ;; 10 ;; (update-from-cspace (_type_) none 10)
|
|
(impact-control-method-11 () none) ;; 11 ;; (impact-control-method-11 (_type_ collide-query process pat-surface) float 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype point-tracker (structure)
|
|
((trans vector 2 :offset-assert 0) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x20
|
|
:flag-assert #xc00000020
|
|
(:methods
|
|
;; (new (symbol type vector vector) _type_ 0)
|
|
(point-tracker-method-9 () none) ;; 9 ;; (initialize (_type_ vector vector) point-tracker 9)
|
|
(point-tracker-method-10 () none) ;; 10 ;; (point-tracker-method-10 (_type_ vector vector vector float) vector 10)
|
|
(point-tracker-method-11 () none) ;; 11 ;; (point-tracker-method-11 (_type_ vector vector vector float) vector 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype combo-tracker (point-tracker)
|
|
((target uint64 :offset-assert 32) ;; handle
|
|
(move-start-time uint64 :offset-assert 40) ;; time-frame
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x30
|
|
:flag-assert #xe00000030
|
|
(:methods
|
|
(combo-tracker-method-12 () none) ;; 12 ;; (combo-tracker-method-12 (_type_ vector vector process time-frame) combo-tracker 12)
|
|
(combo-tracker-method-13 () none) ;; 13 ;; (combo-tracker-method-13 (_type_ handle vector float vector float) basic 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traj2d-params (structure)
|
|
((x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(gravity float :offset-assert 8)
|
|
(initial-tilt float :offset-assert 12)
|
|
(initial-speed float :offset-assert 16)
|
|
(time float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traj3d-params (structure)
|
|
((gravity float :offset-assert 0)
|
|
(initial-tilt float :offset-assert 4)
|
|
(initial-speed float :offset-assert 8)
|
|
(time float :offset-assert 12)
|
|
(src vector :inline :offset-assert 16)
|
|
(dest vector :inline :offset-assert 32)
|
|
(diff vector :inline :offset-assert 48)
|
|
(initial-velocity vector :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cubic-curve (structure)
|
|
((mat matrix :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x40
|
|
:flag-assert #xe00000040
|
|
(:methods
|
|
(cubic-curve-method-9 () none) ;; 9 ;; (cubic-curve-method-9 (_type_ vector vector vector vector) none 9)
|
|
(cubic-curve-method-10 () none) ;; 10 ;; (cubic-curve-method-10 (_type_ vector float) vector 10)
|
|
(cubic-curve-method-11 () none) ;; 11 ;; (cubic-curve-method-11 (_type_ vector float) vector 11)
|
|
(cubic-curve-method-12 () none) ;; 12 ;; (cubic-curve-method-12 (_type_ vector float) vector 12)
|
|
(cubic-curve-method-13 () none) ;; 13 ;; (debug-draw-curve (_type_) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; shadow-vu1-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; memcard-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype mc-handle (int32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
#|
|
|
(deftype mc-file-info (structure)
|
|
((present int32 :offset-assert 0)
|
|
(blind-data float 16 :offset-assert 4) ;; guessed by decompiler
|
|
(blind-data-int8 int8 64 :offset-assert 4) ;; guessed by decompiler
|
|
(level-index int32 :offset-assert 4)
|
|
(gem-count float :offset-assert 8)
|
|
(skill-count float :offset-assert 12)
|
|
(completion-percentage float :offset-assert 16)
|
|
(minute uint8 :offset-assert 24)
|
|
(hour uint8 :offset-assert 25)
|
|
(week uint8 :offset-assert 26)
|
|
(day uint8 :offset-assert 27)
|
|
(month uint8 :offset-assert 28)
|
|
(year uint8 :offset-assert 29)
|
|
(language uint8 :offset-assert 30)
|
|
(game-time0 uint32 :offset-assert 36)
|
|
(game-time1 uint32 :offset-assert 40)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mc-slot-info (structure)
|
|
((handle int32 :offset-assert 0)
|
|
(known int32 :offset-assert 4)
|
|
(formatted int32 :offset-assert 8)
|
|
(inited int32 :offset-assert 12)
|
|
(last-file int32 :offset-assert 16)
|
|
(mem-required int32 :offset-assert 20)
|
|
(mem-actual int32 :offset-assert 24)
|
|
(file mc-file-info 4 :offset-assert 28) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x12c
|
|
:flag-assert #x90000012c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern mc-sync function) ;; (function int)
|
|
;; (define-extern show-mc-info function) ;; (function dma-buffer none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; game-info-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype game-bank (basic)
|
|
((life-max-default float :offset-assert 4)
|
|
(life-start-default float :offset-assert 8)
|
|
(life-single-inc float :offset-assert 12)
|
|
(money-task-inc float :offset-assert 16)
|
|
(money-oracle-inc float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; (deftype actor-id (uint32)
|
|
;; ()
|
|
;; :flag-assert #x900000004
|
|
;; )
|
|
|
|
#|
|
|
(deftype highscore-info (structure)
|
|
((flags uint8 :offset-assert 0) ;; highscore-flags
|
|
(award-scores float 3 :offset-assert 4) ;; guessed by decompiler
|
|
(bronze-score float :offset-assert 4)
|
|
(silver-score float :offset-assert 8)
|
|
(gold-score float :offset-assert 12)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x10
|
|
:flag-assert #xa00000010
|
|
(:methods
|
|
(highscore-info-method-9 () none) ;; 9 ;; (get-rank (_type_ float) int 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype level-buffer-state (structure)
|
|
((name symbol :offset-assert 0) ;; guessed by decompiler
|
|
(display? symbol :offset-assert 4) ;; guessed by decompiler
|
|
(force-vis? symbol :offset-assert 8) ;; guessed by decompiler
|
|
(force-inside? symbol :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype level-buffer-state-small (structure)
|
|
((name basic :offset-assert 0)
|
|
(display? basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype load-state (basic)
|
|
((want level-buffer-state 10 :offset-assert 4) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(want-exp UNKNOWN 10 :offset-assert 164)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(target UNKNOWN 10 :offset-assert 324)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(want-sound symbol 3 :offset-assert 484) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(want-exp-sound UNKNOWN 6 :offset-assert 508)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(target-sound UNKNOWN 6 :offset-assert 556)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(vis-nick symbol :offset-assert 604) ;; guessed by decompiler
|
|
(command-list pair :offset-assert 608) ;; guessed by decompiler
|
|
(object-name string 256 :offset-assert 612) ;; guessed by decompiler
|
|
(object-status basic 256 :offset-assert 1636) ;; guessed by decompiler
|
|
(update-callback basic :offset-assert 2660)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xa68
|
|
:flag-assert #x1600000a68
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(load-state-method-9 () none) ;; 9 ;; (reset! (_type_) _type_ 9)
|
|
(load-state-method-10 () none) ;; 10 ;; (update! (_type_) int 10)
|
|
(load-state-method-11 () none) ;; 11 ;; (want-levels (_type_ (pointer symbol)) int 11)
|
|
(load-state-method-12 () none) ;; 12 ;; (want-sound-banks (_type_ (pointer symbol)) none 12)
|
|
(load-state-method-13 () none) ;; 13 ;; (want-display-level (_type_ symbol symbol) int 13)
|
|
(load-state-method-14 () none) ;; 14 ;; (want-vis-level (_type_ symbol) none 14)
|
|
(load-state-method-15 () none) ;; 15 ;; (want-force-vis (_type_ symbol symbol) int 15)
|
|
(load-state-method-16 () none) ;; 16 ;; (want-force-inside (_type_ symbol symbol) none 16)
|
|
(load-state-method-17 () none) ;; 17 ;; (execute-commands-up-to (_type_ float) none 17)
|
|
(load-state-method-18 () none) ;; 18 ;; (backup-load-state-and-set-cmds (_type_ pair) int 18)
|
|
(load-state-method-19 () none) ;; 19 ;; (restore-load-state-and-cleanup (_type_) int 19)
|
|
(load-state-method-20 () none) ;; 20 ;; (restore-load-state (_type_) int 20)
|
|
(load-state-method-21 () none) ;; 21 ;; (add-borrow-levels (_type_) none 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype continue-point (basic)
|
|
((name string :offset-assert 4) ;; guessed by decompiler
|
|
(level symbol :offset-assert 8) ;; guessed by decompiler
|
|
(flags continue-flags :offset-assert 12) ;; guessed by decompiler
|
|
(trans vector :inline :offset-assert 16)
|
|
(camera-trans vector :inline :offset-assert 32)
|
|
(quat vector4h :inline :offset-assert 48) ;; vector :inline
|
|
(camera-rot vector3s 9 :offset-assert 56) ;; guessed by decompiler
|
|
(on-goto pair :offset-assert 76) ;; guessed by decompiler
|
|
(vis-nick symbol :offset-assert 80) ;; guessed by decompiler
|
|
(vehicle-type uint8 :offset-assert 84)
|
|
(want-count int8 :offset-assert 85)
|
|
(want level-buffer-state :offset-assert 88) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(want-sound symbol 3 :offset-assert 92) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x68
|
|
:flag-assert #xc00000068
|
|
;; field on-goto uses ~A with a signed load.
|
|
(:methods
|
|
(continue-point-method-9 () none) ;; 9 ;; (debug-draw (_type_) int 9)
|
|
(continue-point-method-10 () none) ;; 10 ;; (continue-point-method-10 (_type_ load-state) continue-point 10)
|
|
(continue-point-method-11 () none) ;; 11 ;; (move-camera! (_type_) none 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype game-info (basic)
|
|
((mode symbol :offset-assert 4) ;; guessed by decompiler
|
|
(save-name string :offset-assert 8) ;; guessed by decompiler
|
|
(life float :offset-assert 12)
|
|
(life-max float :offset-assert 16)
|
|
(money float :offset-assert 20)
|
|
(money-total float :offset-assert 24)
|
|
(money-per-level uint8 32 :offset-assert 28) ;; guessed by decompiler
|
|
(deaths-per-level uint8 32 :offset-assert 60) ;; guessed by decompiler
|
|
(buzzer-total float :offset-assert 92)
|
|
(fuel float :offset-assert 96)
|
|
(gem float :offset-assert 100)
|
|
(gem-total float :offset-assert 104)
|
|
(skill float :offset-assert 108)
|
|
(skill-total float :offset-assert 112)
|
|
(skill-high-watermark float :offset-assert 116)
|
|
(light-crystal float :offset-assert 120)
|
|
(dark-crystal float :offset-assert 124)
|
|
(karma float :offset-assert 128)
|
|
(eco-pill-dark float :offset-assert 132)
|
|
(eco-pill-dark-total float :offset-assert 136)
|
|
(eco-pill-light float :offset-assert 140)
|
|
(eco-pill-light-total float :offset-assert 144)
|
|
(features uint64 :offset-assert 152) ;; game-feature
|
|
(debug-features uint64 :offset-assert 160) ;; game-feature
|
|
(old-features uint64 :offset-assert 168)
|
|
(items uint64 :offset-assert 176)
|
|
(debug-items uint64 :offset-assert 184)
|
|
(old-items uint64 :offset-assert 192)
|
|
(secrets uint64 :offset-assert 200) ;; game-secrets
|
|
(purchase-secrets uint64 :offset-assert 208) ;; game-secrets
|
|
(gun-type int32 :offset-assert 216) ;; pickup-type
|
|
(gun-ammo float 4 :offset-assert 220) ;; guessed by decompiler
|
|
(shield float :offset-assert 236)
|
|
(vehicles uint64 :offset-assert 240)
|
|
(debug-vehicles uint64 :offset-assert 248)
|
|
(old-vehicles uint64 :offset-assert 256)
|
|
(score float :offset-assert 264)
|
|
(score-owner uint64 :offset-assert 272) ;; handle
|
|
(timer uint64 :offset-assert 280) ;; time-frame
|
|
(timer-owner uint64 :offset-assert 288) ;; handle
|
|
(timer-flash symbol :offset-assert 296) ;; guessed by decompiler
|
|
(counter float :offset-assert 300)
|
|
(counter-flash basic :offset-assert 304)
|
|
(health-bar float :offset-assert 308)
|
|
(health-bar-owner uint64 :offset-assert 312)
|
|
(enemies-killed float :offset-assert 320)
|
|
(civilians-killed float :offset-assert 324)
|
|
(marauders-killed float :offset-assert 328)
|
|
(shots-fired UNKNOWN 4 :offset-assert 332)
|
|
(shots-hit UNKNOWN 4 :offset-assert 348)
|
|
(crates-opened float :offset-assert 364)
|
|
(health-collected float :offset-assert 368)
|
|
(board-time uint64 :offset-assert 376)
|
|
(attack-id uint32 :offset-assert 384)
|
|
(perm-list entity-perm-array :offset-assert 388) ;; guessed by decompiler
|
|
(task-perm-list entity-perm-array :offset-assert 392) ;; guessed by decompiler
|
|
(current-continue continue-point :offset-assert 396) ;; guessed by decompiler
|
|
(last-continue continue-point :offset-assert 400) ;; guessed by decompiler
|
|
(task-node-commands basic :offset-assert 416)
|
|
(task-node-exclusive basic :offset-assert 420)
|
|
(task-counter uint32 :offset-assert 424)
|
|
(level-opened uint8 32 :offset-assert 432) ;; guessed by decompiler
|
|
(total-deaths int32 :offset-assert 464)
|
|
(continue-deaths int32 :offset-assert 468)
|
|
(task-deaths int32 :offset-assert 472)
|
|
(total-trys int32 :offset-assert 476)
|
|
(game-start-time uint64 :offset-assert 480) ;; time-frame
|
|
(continue-time uint64 :offset-assert 488) ;; time-frame
|
|
(death-time uint64 :offset-assert 496) ;; time-frame
|
|
(hit-time uint64 :offset-assert 504) ;; time-frame
|
|
(task-pickup-time uint64 :offset-assert 512) ;; time-frame
|
|
(death-pos vector-array :offset-assert 532) ;; guessed by decompiler
|
|
(stop-watch-start uint64 :offset-assert 536)
|
|
(stop-watch-stop uint64 :offset-assert 544)
|
|
(blackout-time uint64 :offset-assert 552) ;; time-frame
|
|
(letterbox-time uint64 :offset-assert 560) ;; time-frame
|
|
(hint-play-time uint64 :offset-assert 568) ;; time-frame
|
|
(display-text-time uint64 :offset-assert 576) ;; time-frame
|
|
(display-text-handle uint64 :offset-assert 584) ;; handle
|
|
(death-movie-tick int32 :offset-assert 592)
|
|
(want-auto-save symbol :offset-assert 596) ;; guessed by decompiler
|
|
(auto-save-proc uint64 :offset-assert 600) ;; handle
|
|
(auto-save-status mc-status-code :offset-assert 608) ;; guessed by decompiler
|
|
(auto-save-card int32 :offset-assert 612)
|
|
(auto-save-which int32 :offset-assert 616)
|
|
(auto-save-count int32 :offset-assert 620)
|
|
(pov-camera-handle uint64 :offset-assert 624) ;; handle
|
|
(other-camera-handle uint64 :offset-assert 632) ;; handle
|
|
(controller handle 2 :offset-assert 640) ;; guessed by decompiler
|
|
(race-timer uint64 :offset-assert 656)
|
|
(race-current-lap-count int32 :offset-assert 664)
|
|
(race-total-lap-count int32 :offset-assert 668)
|
|
(race-position int32 :offset-assert 672)
|
|
(race-number-turbos int32 :offset-assert 676)
|
|
(bot-health float 3 :offset-assert 680) ;; guessed by decompiler
|
|
(demo-state uint32 :offset-assert 692)
|
|
(wanted-flash symbol :offset-assert 696) ;; guessed by decompiler
|
|
(distance float :offset-assert 700)
|
|
(kiosk-timeout uint64 :offset-assert 704)
|
|
(pause-start-time uint64 :offset-assert 712) ;; time-frame
|
|
(game-score (array float) :offset-assert 720) ;; guessed by decompiler
|
|
(goal float :offset-assert 724)
|
|
(miss float :offset-assert 728)
|
|
(miss-max float :offset-assert 732)
|
|
(live-eco-pill-count int32 :offset-assert 740)
|
|
(live-gem-count int32 :offset-assert 744)
|
|
(air-supply float :offset-assert 748)
|
|
(homing-beacon int32 :offset-assert 752)
|
|
(dark-eco-pickup int32 :offset-assert 756)
|
|
(green-eco-pickup int32 :offset-assert 760)
|
|
(health-bar-vehicle float :offset-assert 764)
|
|
(dust-storm uint64 :offset-assert 768)
|
|
(flut-count int32 :offset-assert 776)
|
|
(death-resetter resetter-spec :inline :offset-assert 780)
|
|
(current-vehicle uint8 :offset-assert 796)
|
|
(vehicle-turbo-ready float :offset-assert 800)
|
|
(percent-complete float :offset-assert 804)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x328
|
|
:flag-assert #x2300000328
|
|
(:methods
|
|
(game-info-method-9 () none) ;; 9 ;; (initialize! (_type_ symbol game-save string) _type_ 9)
|
|
(game-info-method-10 () none) ;; 10 ;; (give (_type_ symbol float handle) float 10)
|
|
(game-info-method-11 () none) ;; 11 ;; (task-complete? (_type_ game-task) symbol 11)
|
|
(game-info-method-12 () none) ;; 12 ;; (subtask-index-by-name (_type_ string) int 12)
|
|
(game-info-method-13 () none) ;; 13 ;; (set-subtask-hook! (_type_ game-task-node int function) function 13)
|
|
(game-info-method-14 () none) ;; 14 ;; (actor-perm (_type_ actor-id) entity-perm 14)
|
|
(game-info-method-15 () none) ;; 15 ;; (task-perm-by-index (_type_ int) entity-perm 15)
|
|
(game-info-method-16 () none) ;; 16 ;; (copy-perms-from-level! (_type_ level) int 16)
|
|
(game-info-method-17 () none) ;; 17 ;; (copy-perms-to-level! (_type_ level) int 17)
|
|
(game-info-method-18 () none) ;; 18 ;; (debug-inspect (_type_ symbol) _type_ 18)
|
|
(game-info-method-19 () none) ;; 19 ;; (get-current-continue-forced (_type_) continue-point 19)
|
|
(game-info-method-20 () none) ;; 20 ;; (get-continue-by-name (_type_ string) continue-point 20)
|
|
(game-info-method-21 () none) ;; 21 ;; (set-continue! (_type_ basic symbol) continue-point 21)
|
|
(game-info-method-22 () none) ;; 22 ;; (game-info-method-22 (_type_) int 22)
|
|
(game-info-method-23 () none) ;; 23 ;; (save-game (_type_ game-save string) game-save 23)
|
|
(game-info-method-24 () none) ;; 24 ;; (load-game (_type_ game-save) game-save 24)
|
|
(game-info-method-25 () none) ;; 25 ;; (you-suck-stage (_type_ symbol) int 25)
|
|
(game-info-method-26 () none) ;; 26 ;; (you-suck-scale (_type_ object) float 26)
|
|
(game-info-method-27 () none) ;; 27 ;; (get-next-attack-id (_type_) uint 27)
|
|
(game-info-method-28 () none) ;; 28 ;; (game-info-method-28 (_type_ game-score float) int 28)
|
|
(game-info-method-29 () none) ;; 29 ;; (get-game-score-ref (_type_ int) (pointer float) 29)
|
|
(game-info-method-30 () none) ;; 30 ;; (calculate-percentage (_type_) float 30)
|
|
(game-info-method-31 () none) ;; 31
|
|
(game-info-method-32 () none) ;; 32
|
|
(game-info-method-33 () none) ;; 33
|
|
(game-info-method-34 () none) ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *GAME-bank* game-bank) ;; game-bank
|
|
;; (define-extern *game-info* object) ;; game-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-enemy ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *nav-enemy-dummy-shadow-control* shadow-control) ;; shadow-control
|
|
;; (define-extern nav-enemy-simple-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-die-falling-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-travel-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-patrol-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-chase-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-flee-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-face-focus-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-stare-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-falling-post function) ;; (function none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-turn-to-face-dir function) ;; (function vector float none :behavior nav-enemy)
|
|
;; (define-extern nav-enemy-turn-to-face-point function) ;; (function vector float none :behavior nav-enemy)
|
|
;; (define-extern *nav-enemy-debug-control-info* nav-enemy-debug-control-info) ;; nav-enemy-debug-control-info
|
|
;; (define-extern nav-enemy-debug-control-post function) ;; (function none :behavior nav-enemy)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; joint-exploder ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype joint-exploder-tuning (structure)
|
|
((explosion uint64 :offset-assert 0)
|
|
(duration uint64 :offset-assert 8) ;; time-frame
|
|
(gravity float :offset-assert 16)
|
|
(rot-speed float :offset-assert 20)
|
|
(bounds-inflate float :offset-assert 24)
|
|
(max-probes uint8 :offset-assert 28)
|
|
(max-probe-width float :offset-assert 32)
|
|
(max-probe-height float :offset-assert 36)
|
|
(max-probe-depth float :offset-assert 40)
|
|
(friction float :offset-assert 44)
|
|
(fountain-rand-transv-lo vector :inline :offset-assert 48)
|
|
(fountain-rand-transv-hi vector :inline :offset-assert 64)
|
|
(away-from-focal-pt vector :inline :offset-assert 48)
|
|
(away-from-rand-transv-xz-lo float :offset-assert 64)
|
|
(away-from-rand-transv-xz-hi float :offset-assert 68)
|
|
(away-from-rand-transv-y-lo float :offset-assert 72)
|
|
(away-from-rand-transv-y-hi float :offset-assert 76)
|
|
(hit-xz-reaction float :offset-assert 80)
|
|
(hit-y-reaction float :offset-assert 84)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x58
|
|
:flag-assert #x900000058
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-exploder-static-joint-params (structure)
|
|
((joint-index int16 :offset-assert 0)
|
|
(parent-joint-index int16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-exploder-static-params (basic)
|
|
((joints (array joint-exploder-static-joint-params) :offset-assert 4) ;; guessed by decompiler
|
|
(collide-spec uint32 :offset-assert 8)
|
|
(art-level symbol :offset-assert 12) ;; guessed by decompiler
|
|
(collide-sound uint128 :offset-assert 16)
|
|
(collide-sound-interval uint64 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-exploder-joint (structure)
|
|
((next int16 :offset-assert 0)
|
|
(prev int16 :offset-assert 2)
|
|
(joint-index int16 :offset-assert 4)
|
|
(mat matrix :inline :offset-assert 16)
|
|
(rmat matrix :inline :offset-assert 80)
|
|
(update-rmat matrix :inline :offset-assert 144)
|
|
(transv vector :inline :offset-assert 208)
|
|
(prev-pos vector :inline :offset-assert 224)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf0
|
|
:flag-assert #x9000000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-exploder-joints (basic)
|
|
((num-joints int32 :offset-assert 4)
|
|
(joint joint-exploder-joint :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-exploder-list (structure)
|
|
((head int32 :offset-assert 0)
|
|
(pre-moved? symbol :offset-assert 4) ;; guessed by decompiler
|
|
(bbox-valid? symbol :offset-assert 8) ;; guessed by decompiler
|
|
(probeless? symbol :offset-assert 12) ;; guessed by decompiler
|
|
(bbox bounding-box :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-exploder-list-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-exploder (process-drawable)
|
|
((die-if-below-y float :offset-assert 200)
|
|
(die-if-beyond-xz-dist-sqrd float :offset-assert 204)
|
|
(joints joint-exploder-joints :offset-assert 208) ;; guessed by decompiler
|
|
(static-params joint-exploder-static-params :offset-assert 212) ;; guessed by decompiler
|
|
(anim art-joint-anim :offset-assert 216) ;; guessed by decompiler
|
|
(scale-vector vector :inline :offset-assert 224)
|
|
(tuning joint-exploder-tuning :inline :offset-assert 240)
|
|
(lists joint-exploder-list :offset-assert 328) ;; guessed by decompiler
|
|
(last-colsound-time uint64 :offset-assert 336)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x158
|
|
:flag-assert #x1e00e00158
|
|
(:methods
|
|
(joint-exploder-method-20 () none) ;; 20 ;; (add-joint-to-list (_type_ joint-exploder-list int) int 20)
|
|
(joint-exploder-method-21 () none) ;; 21 ;; (update-bbox-for-joint (_type_ joint-exploder-list joint-exploder-joint) none 21)
|
|
(joint-exploder-method-22 () none) ;; 22 ;; (do-collision-response (_type_ joint-exploder-list) none 22)
|
|
(joint-exploder-method-23 () none) ;; 23 ;; (init-joint-list (_type_) none 23)
|
|
(joint-exploder-method-24 () none) ;; 24 ;; (remove-from-list-and-reset (_type_ joint-exploder-list int) int 24)
|
|
(joint-exploder-method-25 () none) ;; 25 ;; (final-adjust (_type_ joint-exploder-list int) int 25)
|
|
(joint-exploder-method-26 () none) ;; 26 ;; (integrate-and-kill (_type_ joint-exploder-list) none 26)
|
|
(joint-exploder-method-27 () none) ;; 27 ;; (remove-joint-from-list (_type_ joint-exploder-list int) int 27)
|
|
(joint-exploder-method-28 () none) ;; 28 ;; (adjust-bbox-for-limits-along-axis (_type_ joint-exploder-list int) joint-exploder-list 28)
|
|
(joint-exploder-method-29 () none) ;; 29 ;; (adjust-bbox-for-limits (_type_ joint-exploder-list) none 29)
|
|
)
|
|
(:states
|
|
joint-exploder-shatter ;; associated process guessed by decompiler, old: (state joint-exploder)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern joint-exploder-joint-callback function) ;; (function draw-control cspace-array joint-control none)
|
|
;; (define-extern joint-exploder-init-by-other function) ;; (function skeleton-group int joint-exploder-tuning joint-exploder-static-params none :behavior joint-exploder)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gui-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gui-connection (connection)
|
|
((priority float :offset-assert 16)
|
|
(action uint8 :offset-assert 20) ;; gui-action
|
|
(channel uint8 :offset-assert 21) ;; gui-channel
|
|
(anim-part uint8 :offset-assert 22)
|
|
(flags uint8 :offset-assert 23) ;; gui-connection-flags
|
|
(name string :offset-assert 24) ;; guessed by decompiler
|
|
(id sound-id :offset-assert 28) ;; guessed by decompiler
|
|
(handle uint64 :offset-assert 0) ;; handle
|
|
(time-stamp uint64 :offset-assert 8) ;; time-frame
|
|
(hold-time uint64 :offset-assert 32) ;; time-frame
|
|
(fo-min int16 :offset-assert 40)
|
|
(fo-max int16 :offset-assert 42)
|
|
(fo-curve int8 :offset-assert 44)
|
|
(fade uint8 :offset-assert 45)
|
|
(volume int16 :offset-assert 46)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x30
|
|
:flag-assert #xe00000030
|
|
;; field param1 uses ~A with a signed load. field param2 uses ~A with a signed load. field param3 uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
;; (deftype gui-control (basic)
|
|
;; ()
|
|
;; :flag-assert #x1a00000d30
|
|
;; )
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; h-torpedo ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype htorpedo (h-bike-c)
|
|
((speed float :offset-assert 1296)
|
|
(target-speed float :offset-assert 1300)
|
|
(pitch float :offset-assert 1304)
|
|
(target-pitch float :offset-assert 1308)
|
|
(max-pitch float :offset-assert 1312)
|
|
(roll float :offset-assert 1316)
|
|
(target-roll float :offset-assert 1320)
|
|
(turn-rate float :offset-assert 1324)
|
|
(target-turn-rate float :offset-assert 1328)
|
|
(ground-height float :offset-assert 1332)
|
|
(ground-offset float :offset-assert 1336)
|
|
(down-force float :offset-assert 1340)
|
|
(want-jump? basic :offset-assert 1344)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(jump-state uint8 :offset-assert 1360)
|
|
(on-water? basic :offset-assert 1364)
|
|
(cam-pitch float :offset-assert 1368)
|
|
(cam-roll float :offset-assert 1372)
|
|
(target-cam-roll float :offset-assert 1376)
|
|
(based-cam-roll float :offset-assert 1380)
|
|
(last-quat quaternion :inline :offset-assert 1392)
|
|
(override-camera? basic :offset-assert 1408)
|
|
(under-water? basic :offset-assert 1412)
|
|
(next-bob-cam-time uint64 :offset-assert 1416)
|
|
(thrust-sound uint32 :offset-assert 1424)
|
|
(ground-sound uint32 :offset-assert 1428)
|
|
(reverb-dest float :offset-assert 1432)
|
|
(pitch-current float :offset-assert 1436)
|
|
(ground-vol-current float :offset-assert 1440)
|
|
(last-slice-val float :offset-assert 1444)
|
|
(evasive-sound uint32 :offset-assert 1448)
|
|
(evasive-volume float :offset-assert 1452)
|
|
(stopping-evasive? basic :offset-assert 1456)
|
|
(spawn-splash? basic :offset-assert 1460)
|
|
(wake-sound uint32 :offset-assert 1464)
|
|
(heat-haze basic :offset-assert 1468)
|
|
(last-land-speech-time uint64 :offset-assert 1472)
|
|
(last-jump-speech-time uint64 :offset-assert 1480)
|
|
)
|
|
:method-count-assert 171
|
|
:size-assert #x5d0
|
|
:flag-assert #xab055005d0
|
|
(:methods
|
|
(htorpedo-method-162 () none) ;; 162
|
|
(htorpedo-method-164 () none) ;; 164
|
|
(htorpedo-method-165 () none) ;; 165
|
|
(htorpedo-method-166 () none) ;; 166
|
|
(htorpedo-method-167 () none) ;; 167
|
|
(htorpedo-method-168 () none) ;; 168
|
|
(htorpedo-method-169 () none) ;; 169
|
|
(htorpedo-method-170 () none) ;; 170
|
|
)
|
|
(:state-methods
|
|
waiting ;; 57
|
|
hide ;; 163
|
|
player-control ;; 58
|
|
explode ;; 60
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-tracker-torpedo (light-trail-tracker)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xac
|
|
:flag-assert #x15003000ac
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *growing-curve-torpedo* object)
|
|
;; (define-extern *water-simple-alpha-curve-fade-out-torpedo* object)
|
|
;; (define-extern *color-curve-tan-brown-torpedo* object)
|
|
;; (define-extern *water-simple-alpha-curve-in-torpedo* object)
|
|
;; (define-extern *torpedo-wake-trail* object)
|
|
;; (define-extern spt-func-nuke-water-splash function)
|
|
;; (define-extern *range-torp-explo-color* curve-color-fast)
|
|
;; (define-extern *range-torp-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-torp-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-torp-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-torp-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-torp-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-torp-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-torpedo-explosion-texture-curve-settings* object)
|
|
;; (define-extern PHYSICS_SCALAR object)
|
|
;; (define-extern *torpedo-speech-list* object)
|
|
;; (define-extern *torpedo-jump-speech* array)
|
|
;; (define-extern *torpedo-land-speech* array)
|
|
;; (define-extern *h-torpedo-constants* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; subdivide-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype subdivide-settings (basic)
|
|
((dist float 5 :offset-assert 4) ;; guessed by decompiler
|
|
(meters float 5 :offset-assert 24) ;; guessed by decompiler
|
|
(close float 12 :offset-assert 44) ;; guessed by decompiler
|
|
(far float 12 :offset-assert 92) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8c
|
|
:flag-assert #x90000008c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype subdivide-dists (structure)
|
|
((data uint32 32 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 8 :offset-assert 0) ;; guessed by decompiler
|
|
(k0s uint128 4 :offset-assert 0) ;; guessed by decompiler
|
|
(k1s uint128 4 :offset-assert 64) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terrain-stats (structure)
|
|
((pris tr-stat :inline :offset-assert 0)
|
|
(tie-generic tr-stat :inline :offset-assert 16)
|
|
(tie-vanish tr-stat :inline :offset-assert 32)
|
|
(tie tr-stat :inline :offset-assert 48)
|
|
(tie-scissor tr-stat :inline :offset-assert 64)
|
|
(tie-envmap tr-stat :inline :offset-assert 80)
|
|
(tie-envmap-scissor tr-stat :inline :offset-assert 96)
|
|
(tie-trans tr-stat :inline :offset-assert 112)
|
|
(tie-scissor-trans tr-stat :inline :offset-assert 128)
|
|
(tie-envmap-trans tr-stat :inline :offset-assert 144)
|
|
(tie-envmap-scissor-trans tr-stat :inline :offset-assert 160)
|
|
(tie-water tr-stat :inline :offset-assert 176)
|
|
(tie-scissor-water tr-stat :inline :offset-assert 192)
|
|
(tie-envmap-water tr-stat :inline :offset-assert 208)
|
|
(tie-envmap-scissor-water tr-stat :inline :offset-assert 224)
|
|
(shrub-near tr-stat :inline :offset-assert 240)
|
|
(shrub tr-stat :inline :offset-assert 256)
|
|
(tfrag-scissor tr-stat :inline :offset-assert 272)
|
|
(tfrag tr-stat :inline :offset-assert 288)
|
|
(billboard tr-stat :inline :offset-assert 304)
|
|
(tfrag-trans tr-stat :inline :offset-assert 320)
|
|
(tfrag-scissor-trans tr-stat :inline :offset-assert 336)
|
|
(tfrag-water tr-stat :inline :offset-assert 352)
|
|
(tfrag-scissor-water tr-stat :inline :offset-assert 368)
|
|
(trans-pris tr-stat :inline :offset-assert 384)
|
|
(trans-shrub tr-stat :inline :offset-assert 400)
|
|
(ocean-mid tr-stat :inline :offset-assert 416)
|
|
(ocean-near tr-stat :inline :offset-assert 432)
|
|
(shadow tr-stat :inline :offset-assert 448)
|
|
(hfrag tr-stat :inline :offset-assert 464)
|
|
(total tr-stat :inline :offset-assert 480)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1f0
|
|
:flag-assert #x9000001f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype background-area (structure)
|
|
((dma-area dma-area 14336 :offset-assert 0) ;; guessed by decompiler
|
|
(vis-list uint8 2048 :offset-assert 14336) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4000
|
|
:flag-assert #x900004000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype foreground-area (structure)
|
|
((generic-work generic-work :inline :offset-assert 0)
|
|
(foreground-work foreground-work :inline :offset-assert 0)
|
|
(joint-work joint-work :inline :offset-assert 0)
|
|
(bone-mem bone-memory :inline :offset-assert 0)
|
|
(shadow-work shadow-work :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3fe0
|
|
:flag-assert #x900003fe0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype region-prim-area (structure)
|
|
((region-prim-list region-prim-list :inline :offset-assert 0)
|
|
(pos vector :inline :offset-assert 1296)
|
|
(ray vector :inline :offset-assert 1328)
|
|
(region-enter-count int32 :offset-assert 1360)
|
|
(region-enter-list region 320 :offset-assert 1364) ;; guessed by decompiler
|
|
(region-enter-prim-list drawable-region-sphere 320 :offset-assert 2644) ;; guessed by decompiler
|
|
(region-exit-count int32 :offset-assert 3924)
|
|
(region-exit-list region 320 :offset-assert 3928) ;; guessed by decompiler
|
|
(region-exit-prim-list drawable-region-sphere 320 :offset-assert 5208) ;; guessed by decompiler
|
|
(region-inside-count int32 :offset-assert 6488)
|
|
(region-inside-list region 320 :offset-assert 6492) ;; guessed by decompiler
|
|
(region-inside-prim-list drawable-region-sphere 320 :offset-assert 7772) ;; guessed by decompiler
|
|
(region-start-count int32 :offset-assert 9052)
|
|
(region-start-list region 320 :offset-assert 9056) ;; guessed by decompiler
|
|
(region-start-prim-list drawable-region-sphere 320 :offset-assert 10336) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x2d60
|
|
:flag-assert #xd00002d60
|
|
(:methods
|
|
(region-prim-area-method-9 () none) ;; 9 ;; (track-entered-region! (_type_ drawable-region-sphere) none 9)
|
|
(region-prim-area-method-10 () none) ;; 10 ;; (track-exited-region! (_type_ drawable-region-sphere) none 10)
|
|
(region-prim-area-method-11 () none) ;; 11 ;; (track-inside-region! (_type_ drawable-region-sphere) none 11)
|
|
(region-prim-area-method-12 () none) ;; 12 ;; (track-start-region! (_type_ drawable-region-sphere) none 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-area (structure)
|
|
((clock-data vector 22 :offset-assert 0) ;; guessed by decompiler
|
|
(buffer uint8 :dynamic :offset-assert 352) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x160
|
|
:flag-assert #x900000160
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype work-area (structure)
|
|
((background background-area :inline :offset-assert 0)
|
|
(foreground foreground-area :inline :offset-assert 0)
|
|
(region-prim region-prim-area :inline :offset-assert 0)
|
|
(sprite sprite-area :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4000
|
|
:flag-assert #x900004000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terrain-context (structure)
|
|
((work work-area :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4000
|
|
:flag-assert #x900004000
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *terrain-stats* object) ;; terrain-stats
|
|
;; (define-extern *collide-stats* object) ;; collide-stats
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ambient-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype talker-speech-class (structure)
|
|
((name string :offset-assert 0) ;; guessed by decompiler
|
|
(channel uint8 :offset-assert 4) ;; gui-channel
|
|
(flags uint16 :offset-assert 6) ;; uint8
|
|
(speech uint16 :offset-assert 8)
|
|
(text-duration uint16 :offset-assert 10)
|
|
(delay uint16 :offset-assert 12)
|
|
(pos uint16 :offset-assert 14)
|
|
(neg uint16 :offset-assert 16)
|
|
(text-message text-id :offset-assert 20) ;; guessed by decompiler
|
|
(on-close pair :offset-assert 24) ;; guessed by decompiler
|
|
(camera basic :offset-assert 28)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x20
|
|
:flag-assert #xe00000020
|
|
;; field on-close uses ~A with a signed load.
|
|
(:methods
|
|
(talker-speech-class-method-9 () none) ;; 9 ;; (talker-speech-class-method-9 (_type_) symbol 9)
|
|
(talker-speech-class-method-10 () none) ;; 10 ;; (play-communicator-speech! (_type_) none 10)
|
|
(talker-speech-class-method-11 () none) ;; 11 ;; (talker-speech-class-method-11 (_type_) none 11)
|
|
(talker-speech-class-method-12 () none) ;; 12 ;; (talker-speech-class-method-12 (_type_ int) none 12)
|
|
(talker-speech-class-method-13 () none) ;; 13 ;; (talker-speech-class-method-13 (_type_ int) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype talker (process)
|
|
((trans vector :inline :offset-assert 128)
|
|
(message talker-speech-class :offset-assert 144)
|
|
(total-time uint64 :offset-assert 152) ;; time-frame
|
|
(total-off-time uint64 :offset-assert 160) ;; time-frame
|
|
(start-time uint64 :offset-assert 168) ;; time-frame
|
|
(state-time uint64 :offset-assert 176) ;; time-frame
|
|
(voicebox uint64 :offset-assert 184) ;; handle
|
|
(voice-id sound-id :offset-assert 192) ;; guessed by decompiler
|
|
(message-id sound-id :offset-assert 196) ;; guessed by decompiler
|
|
(region region :offset-assert 200)
|
|
(interp float :offset-assert 204)
|
|
(save? symbol :offset-assert 208) ;; guessed by decompiler
|
|
(grab? basic :offset-assert 212)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #xd8
|
|
:flag-assert #x12006000d8
|
|
(:methods
|
|
(talker-method-14 () none) ;; 14 ;; (idle () _type_ :state 14)
|
|
(talker-method-15 () none) ;; 15 ;; (active () _type_ :state 15)
|
|
(talker-method-16 () none) ;; 16 ;; (exit () _type_ :state 16)
|
|
(talker-method-17 () none) ;; 17 ;; (talker-method-17 (_type_) none 17)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *talker-speech* object) ;; (inline-array talker-speech-class)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; shadow-cpu ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype shadow-stats (structure)
|
|
((num-single-tris uint32 :offset-assert 0)
|
|
(num-double-tris uint32 :offset-assert 4)
|
|
(num-single-edges uint32 :offset-assert 8)
|
|
(num-double-edges uint32 :offset-assert 12)
|
|
(num-fragments uint16 :offset-assert 16)
|
|
(num-objects uint16 :offset-assert 18)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-dcache (structure)
|
|
((vtx-table uint32 :offset-assert 0)
|
|
(single-edge-table uint32 :offset-assert 4)
|
|
(double-edge-table uint32 :offset-assert 8)
|
|
(double-tri-table uint32 :offset-assert 12)
|
|
(dcache-top uint32 :offset-assert 16)
|
|
(num-facing-single-tris uint32 :offset-assert 20)
|
|
(num-single-edges uint32 :offset-assert 24)
|
|
(num-double-edges uint32 :offset-assert 28)
|
|
(single-tri-list uint32 :offset-assert 32)
|
|
(single-edge-list uint32 :offset-assert 36)
|
|
(double-edge-list uint32 :offset-assert 40)
|
|
(ptr-dual-verts uint32 :offset-assert 44)
|
|
(stats shadow-stats :inline :offset-assert 48)
|
|
(frag-qwc uint32 :offset-assert 68)
|
|
(center vector :inline :offset-assert 80)
|
|
(plane vector :inline :offset-assert 96)
|
|
(top-plane vector :inline :offset-assert 112)
|
|
(near-plane vector :inline :offset-assert 128)
|
|
(light-dir vector :inline :offset-assert 144)
|
|
(vtx-min vector :inline :offset-assert 160)
|
|
(data uint8 :dynamic :offset-assert 176) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xb0
|
|
:flag-assert #x9000000b0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *shadow-data* object) ;; shadow-data
|
|
;; (define-extern shadow-invert-z-buf function) ;; (function dma-buffer none)
|
|
;; (define-extern shadow-make-invert-buf function) ;; (function none)
|
|
;; (define-extern *shadow-dma-invert-call* object) ;; pointer
|
|
;; (define-extern shadow-dma-init function) ;; (function dma-buffer none)
|
|
;; (define-extern shadow-dma-end function) ;; (function dma-buffer gs-rgbaq symbol int none)
|
|
;; (define-extern shadow-vu0-block object) ;; vu-function
|
|
;; (define-extern shadow-xform-verts function) ;; function
|
|
;; (define-extern shadow-calc-dual-verts function) ;; function
|
|
;; (define-extern shadow-scissor-edges function) ;; function
|
|
;; (define-extern shadow-scissor-top function) ;; function
|
|
;; (define-extern shadow-init-vars function) ;; function
|
|
;; (define-extern shadow-find-facing-single-tris function) ;; function
|
|
;; (define-extern shadow-find-single-edges function) ;; function
|
|
;; (define-extern shadow-find-facing-double-tris function) ;; function
|
|
;; (define-extern shadow-find-double-edges function) ;; function
|
|
;; (define-extern shadow-add-verts function) ;; function
|
|
;; (define-extern shadow-add-facing-single-tris function) ;; function
|
|
;; (define-extern shadow-add-single-edges function) ;; function
|
|
;; (define-extern shadow-add-single-tris function) ;; function
|
|
;; (define-extern shadow-add-double-tris function) ;; function
|
|
;; (define-extern shadow-add-double-edges function) ;; function
|
|
;; (define-extern debug-draw-settings function) ;; (function shadow-settings symbol)
|
|
;; (define-extern shadow-execute function) ;; (function shadow-dma-packet pointer pointer)
|
|
;; (define-extern shadow-vu0-upload function) ;; (function none)
|
|
;; (define-extern shadow-execute-all function) ;; (function dma-buffer none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; templex-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *templex-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wind-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wind-vector (structure)
|
|
((wind-pos vector4w :inline :offset-assert 0)
|
|
(wind-vel vector4w :inline :offset-assert 16)
|
|
(stiffness float :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wind-work (basic)
|
|
((wind-array vector 64 :offset-assert 16) ;; guessed by decompiler
|
|
(wind-normal vector :inline :offset-assert 1040)
|
|
(wind-temp vector :inline :offset-assert 1056)
|
|
(wind-force float 64 :offset-assert 1072) ;; guessed by decompiler
|
|
(wind-const vector :inline :offset-assert 1328)
|
|
(wind-time uint32 :offset-assert 1344)
|
|
(wait-to-vu0 uint32 :offset-assert 1348)
|
|
(wait-to-spr uint32 :offset-assert 1352)
|
|
(wait-from-spr uint32 :offset-assert 1356)
|
|
(spr-index uint32 :offset-assert 1360)
|
|
(count uint32 :offset-assert 1364)
|
|
(next-count uint32 :offset-assert 1368)
|
|
(last-count uint32 :offset-assert 1372)
|
|
(to-spr uint32 :offset-assert 1376)
|
|
(from-spr uint32 :offset-assert 1380)
|
|
(next-mem uint32 :offset-assert 1384)
|
|
(last-mem uint32 :offset-assert 1388)
|
|
(next-spr uint32 :offset-assert 1392)
|
|
(last-spr uint32 :offset-assert 1396)
|
|
(to-ptrs uint32 3 :offset-assert 1400) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x584
|
|
:flag-assert #x900000584
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wind-dma (structure)
|
|
((buffer0 wind-vector 128 :offset-assert 0) ;; guessed by decompiler
|
|
(buffer1 wind-vector 128 :offset-assert 4096) ;; guessed by decompiler
|
|
(buffer2 wind-vector 128 :offset-assert 8192) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3000
|
|
:flag-assert #x900003000
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *wind-scales* array) ;; (array uint8)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; conveyor ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype conveyor-section (structure)
|
|
((start vector :inline :offset-assert 0)
|
|
(trailing plane :inline :offset-assert 16)
|
|
(pull-dir vector :inline :offset-assert 32)
|
|
(radial-dir vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype conveyor-section-array (inline-array-class)
|
|
((data conveyor-section :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype conveyor (process-drawable)
|
|
((speed float :offset-assert 200)
|
|
(belt-radius float :offset-assert 204)
|
|
(pull-y-threshold float :offset-assert 208)
|
|
(speed-mult-array (array float) :offset-assert 212) ;; guessed by decompiler
|
|
(speed-mult-array-len int8 :offset-assert 216)
|
|
(sections conveyor-section-array :offset-assert 220) ;; guessed by decompiler
|
|
(leading plane :inline :offset-assert 224)
|
|
(collide-bounds sphere :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
(:methods
|
|
(conveyor-method-21 () none) ;; 21 ;; (conveyor-method-21 (_type_) float 21)
|
|
(conveyor-method-22 () none) ;; 22 ;; (get-art-group (_type_) art-group 22)
|
|
(conveyor-method-23 () none) ;; 23 ;; (reset-root! (_type_) none 23)
|
|
(conveyor-method-24 () none) ;; 24 ;; (init! (_type_) none 24)
|
|
(conveyor-method-25 () none) ;; 25 ;; (set-and-get-ambient-sound! (_type_) ambient-sound 25)
|
|
(conveyor-method-26 () none) ;; 26 ;; (conveyor-method-26 (_type_ process-focusable) symbol 26)
|
|
(conveyor-method-27 () none) ;; 27 ;; (conveyor-method-27 (_type_) symbol 27)
|
|
(conveyor-method-28 () none) ;; 28
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prototype-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype prototype-bucket (basic)
|
|
((name string :offset-assert 4) ;; guessed by decompiler
|
|
(flags uint16 :offset-assert 8) ;; prototype-flags
|
|
(texture-masks-index uint16 :offset-assert 10)
|
|
(in-level uint16 :offset-assert 12)
|
|
(utextures uint16 :offset-assert 14)
|
|
(geometry drawable 4 :offset-assert 16) ;; guessed by decompiler
|
|
(dists vector :inline :offset-assert 32)
|
|
(rdists vector :inline :offset-assert 48)
|
|
(near-plane meters :offset-assert 32)
|
|
(near-stiff meters :offset-assert 36)
|
|
(mid-plane meters :offset-assert 40)
|
|
(far-plane meters :offset-assert 44)
|
|
(rlength-near float :offset-assert 48)
|
|
(rlength-stiff float :offset-assert 52)
|
|
(rlength-mid float :offset-assert 56)
|
|
(stiffness float :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-bucket-shrub (prototype-bucket)
|
|
((next uint32 4 :offset-assert 64) ;; guessed by decompiler
|
|
(count uint16 4 :offset-assert 80) ;; guessed by decompiler
|
|
(mod-count uint16 4 :offset-assert 88) ;; guessed by decompiler
|
|
(last dma-packet 4 :offset-assert 96) ;; guessed by decompiler
|
|
(next-clear uint128 :offset-assert 64)
|
|
(count-clear uint64 :offset-assert 80)
|
|
(last-clear uint128 :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-inline-array-shrub (drawable)
|
|
((length int16 :offset-assert 6)
|
|
(data prototype-bucket-shrub 1 :offset-assert 36) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x94
|
|
:flag-assert #x1100000094
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-array-shrub-info (basic)
|
|
((prototype-inline-array-shrub prototype-inline-array-shrub :offset-assert 4) ;; guessed by decompiler
|
|
(wind-vectors uint32 :offset-assert 8)
|
|
(wind-count int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-bucket-tie (prototype-bucket)
|
|
((next uint32 12 :offset-assert 64) ;; guessed by decompiler
|
|
(count uint16 12 :offset-assert 112) ;; guessed by decompiler
|
|
(frag-count uint8 4 :offset-assert 136) ;; guessed by decompiler
|
|
(index-start uint8 4 :offset-assert 140) ;; guessed by decompiler
|
|
(base-qw uint16 4 :offset-assert 144) ;; guessed by decompiler
|
|
(tie-rvanish float :offset-assert 152)
|
|
(tie-vanish-far float :offset-assert 156)
|
|
(envmap-rfade float :offset-assert 160)
|
|
(envmap-fade-far float :offset-assert 164)
|
|
(envmap-shader adgif-shader :offset-assert 168)
|
|
(tint-color uint32 :offset-assert 172)
|
|
(collide-hash-fragment-array collide-hash-fragment-array :offset-assert 176) ;; guessed by decompiler
|
|
(tie-colors time-of-day-palette :offset-assert 180) ;; guessed by decompiler
|
|
(data uint32 :dynamic :offset-assert 184) ;; guessed by decompiler
|
|
(color-index-qwc uint32 :dynamic :offset-assert 184) ;; guessed by decompiler
|
|
(scissor-frag-count uint8 :offset-assert 136)
|
|
(near-frag-count uint8 :offset-assert 137)
|
|
(mid-frag-count uint8 :offset-assert 138)
|
|
(far-frag-count uint8 :offset-assert 139)
|
|
(scissor-index-start uint8 :offset-assert 140)
|
|
(near-index-start uint8 :offset-assert 141)
|
|
(mid-index-start uint8 :offset-assert 142)
|
|
(far-index-start uint8 :offset-assert 143)
|
|
(scissor-base-qw uint16 :offset-assert 144)
|
|
(near-base-qw uint16 :offset-assert 146)
|
|
(mid-base-qw uint16 :offset-assert 148)
|
|
(far-base-qw uint16 :offset-assert 150)
|
|
(tie-next uint32 4 :offset-assert 64) ;; guessed by decompiler
|
|
(tie-scissor-next uint32 :offset-assert 64)
|
|
(tie-near-next uint32 :offset-assert 68)
|
|
(tie-mid-next uint32 :offset-assert 72)
|
|
(tie-far-next uint32 :offset-assert 76)
|
|
(trans-next uint32 4 :offset-assert 64) ;; guessed by decompiler
|
|
(trans-scissor-next uint32 4 :offset-assert 64) ;; guessed by decompiler
|
|
(trans-near-next uint32 :offset-assert 68)
|
|
(trans-mid-next uint32 :offset-assert 72)
|
|
(trans-far-next uint32 :offset-assert 76)
|
|
(water-next uint32 4 :offset-assert 64) ;; guessed by decompiler
|
|
(water-scissor-next uint32 4 :offset-assert 64) ;; guessed by decompiler
|
|
(water-near-next uint32 :offset-assert 68)
|
|
(water-mid-next uint32 :offset-assert 72)
|
|
(water-far-next uint32 :offset-assert 76)
|
|
(envmap-next uint32 4 :offset-assert 80) ;; guessed by decompiler
|
|
(envmap-scissor-next uint32 4 :offset-assert 80) ;; guessed by decompiler
|
|
(envmap-near-next uint32 :offset-assert 84)
|
|
(envmap-mid-next uint32 :offset-assert 88)
|
|
(envmap-far-next uint32 :offset-assert 92)
|
|
(generic-next uint32 3 :offset-assert 96) ;; guessed by decompiler
|
|
(generic-near-next uint32 :offset-assert 96)
|
|
(generic-mid-next uint32 :offset-assert 100)
|
|
(generic-far-next uint32 :offset-assert 104)
|
|
(vanish-next uint32 :offset-assert 108)
|
|
(tie-count uint16 4 :offset-assert 112) ;; guessed by decompiler
|
|
(tie-scissor-count uint16 :offset-assert 112)
|
|
(tie-near-count uint16 :offset-assert 114)
|
|
(tie-mid-count uint16 :offset-assert 116)
|
|
(tie-far-count uint16 :offset-assert 118)
|
|
(trans-count uint16 4 :offset-assert 112) ;; guessed by decompiler
|
|
(trans-scissor-count uint16 :offset-assert 112)
|
|
(trans-near-count uint16 :offset-assert 114)
|
|
(trans-mid-count uint16 :offset-assert 116)
|
|
(trans-far-count uint16 :offset-assert 118)
|
|
(water-count uint16 4 :offset-assert 112) ;; guessed by decompiler
|
|
(water-scissor-count uint16 :offset-assert 112)
|
|
(water-near-count uint16 :offset-assert 114)
|
|
(water-mid-count uint16 :offset-assert 116)
|
|
(water-far-count uint16 :offset-assert 118)
|
|
(envmap-count uint16 4 :offset-assert 120) ;; guessed by decompiler
|
|
(envmap-scissor-count uint16 :offset-assert 120)
|
|
(envmap-near-count uint16 :offset-assert 122)
|
|
(envmap-mid-count uint16 :offset-assert 124)
|
|
(envmap-far-count uint16 :offset-assert 126)
|
|
(generic-count uint16 3 :offset-assert 128) ;; guessed by decompiler
|
|
(generic-near-count uint16 :offset-assert 128)
|
|
(generic-mid-count uint16 :offset-assert 130)
|
|
(generic-far-count uint16 :offset-assert 132)
|
|
(vanish-count uint16 :offset-assert 134)
|
|
(next-clear uint128 3 :offset-assert 64) ;; guessed by decompiler
|
|
(count-clear uint64 3 :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xb8
|
|
:flag-assert #x9000000b8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-array-tie (array)
|
|
((type type :offset-assert 0) ;; guessed by decompiler
|
|
(length int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
(content-type type :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x10
|
|
:flag-assert #xa00000010
|
|
(:methods
|
|
(prototype-array-tie-method-9 () none) ;; 9 ;; (login (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype proxy-prototype-array-tie (basic)
|
|
((prototype-array-tie prototype-array-tie :offset-assert 4) ;; guessed by decompiler
|
|
(wind-vectors uint32 :offset-assert 8)
|
|
(wind-count uint16 :offset-assert 12)
|
|
(prototype-max-qwc uint16 :offset-assert 14)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype instance (drawable)
|
|
((bucket-index uint16 :offset-assert 6)
|
|
(origin matrix4h :inline :offset-assert 32)
|
|
(flags uint16 :offset-assert 46) ;; instance-flags
|
|
(wind-index uint16 :offset-assert 62)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x40
|
|
:flag-assert #x1100000040
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bug-report ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bug-report (process)
|
|
((bug-number UNKNOWN 5 :offset-assert 128)
|
|
(digit uint32 :offset-assert 148)
|
|
(state-time uint64 :offset-assert 152)
|
|
(next-down uint64 :offset-assert 160)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #xa8
|
|
:flag-assert #x11003000a8
|
|
(:methods
|
|
(bug-report-method-15 () none) ;; 15
|
|
(bug-report-method-16 () none) ;; 16
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *continue-bug-report* continue-point)
|
|
;; (define-extern *bug-report* object)
|
|
;; (define-extern bug-report-init function)
|
|
;; (define-extern bug-report-stop function)
|
|
;; (define-extern bug-report-start function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; course-race ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-race (task-manager)
|
|
((start-pos vector :inline :offset-assert 240)
|
|
(start-continue basic :offset-assert 256)
|
|
(scene-player uint64 :offset-assert 264)
|
|
(race-started? basic :offset-assert 272)
|
|
(player-won? basic :offset-assert 276)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x118
|
|
:flag-assert #x2700a00118
|
|
(:methods
|
|
(task-manager-race-method-33 () none) ;; 33
|
|
(task-manager-race-method-34 () none) ;; 34
|
|
(task-manager-race-method-35 () none) ;; 35
|
|
(task-manager-race-method-36 () none) ;; 36
|
|
(task-manager-race-method-37 () none) ;; 37
|
|
(task-manager-race-method-38 () none) ;; 38
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
finished ;; 32
|
|
complete ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-course-race (task-manager-race)
|
|
((fail-plane vector :inline :offset-assert 288)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x130
|
|
:flag-assert #x2700b00130
|
|
(:state-methods
|
|
active ;; 15
|
|
finished ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bbush-time-trial-hud-info (structure)
|
|
((goal float :offset-assert 0)
|
|
(goal-cup uint8 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5
|
|
:flag-assert #x900000005
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-wasbbv-goal-time (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-time-trial-1 (task-manager-race)
|
|
((game-score uint8 :offset-assert 280)
|
|
(hud-goal uint64 :offset-assert 288)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x128
|
|
:flag-assert #x2700b00128
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-rally-bollard (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-rally (task-manager-race)
|
|
((game-score uint8 :offset-assert 280)
|
|
(hud-goal uint64 :offset-assert 288)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x128
|
|
:flag-assert #x2700b00128
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *v-snake-racer-constants* object)
|
|
;; (define-extern *v-mirage-racer-constants* object)
|
|
;; (define-extern *v-fox-racer-constants* object)
|
|
;; (define-extern *v-x-ride-racer-constants* object)
|
|
;; (define-extern *v-marauder-racer-constants* object)
|
|
;; (define-extern task-manager-race-pre-race-sequence function)
|
|
;; (define-extern task-manager-desert-course-race-pre-race-sequence function)
|
|
;; (define-extern *bbush-time-trial-hud-info* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; joint-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype joint-control-channel (structure)
|
|
((parent joint-control :offset-assert 0) ;; guessed by decompiler
|
|
(frame-group art-joint-anim :offset-assert 4) ;; guessed by decompiler
|
|
(frame-num float :offset-assert 8)
|
|
(dist meters :offset-assert 12)
|
|
(num-func (function joint-control-channel float float float float) :offset-assert 16) ;; guessed by decompiler
|
|
(param float 3 :offset-assert 20) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(frame-interp float 2 :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(inspector-amount uint8 :offset-assert 40)
|
|
(command uint64 :offset-assert 48) ;; joint-control-command
|
|
(group-sub-index int8 :offset-assert 56)
|
|
(group-size int8 :offset-assert 57)
|
|
(eval-time uint32 :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype top-anim-joint-control (basic)
|
|
((process (pointer process-drawable) :offset-assert 4) ;; guessed by decompiler
|
|
(interp-select uint64 2 :offset-assert 8) ;; guessed by decompiler
|
|
(base-anim basic :offset-assert 24)
|
|
(base-anim-speed float :offset-assert 28)
|
|
(base-anim-blend float :offset-assert 32)
|
|
(interp float :offset-assert 36)
|
|
(frame-group art-joint-anim :offset-assert 40) ;; guessed by decompiler
|
|
(frame-group-push art-joint-anim :offset-assert 44) ;; guessed by decompiler
|
|
(frame-num float :offset-assert 48)
|
|
(frame-targ art-joint-anim :offset-assert 52) ;; guessed by decompiler
|
|
(frame-speed float :offset-assert 56)
|
|
(frame-blend float :offset-assert 60)
|
|
(frame-cur-blend float :offset-assert 64)
|
|
(frame-start float :offset-assert 68)
|
|
(frame-post-blend float :offset-assert 72)
|
|
(frame-post-end float :offset-assert 76)
|
|
(frame-push-time uint64 :offset-assert 80) ;; time-frame
|
|
(frame-post-put-away basic :offset-assert 88)
|
|
(update-time uint64 :offset-assert 96) ;; time-frame
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x68
|
|
:flag-assert #xd00000068
|
|
(:methods
|
|
;; (new (symbol type process-drawable) _type_ 0)
|
|
(top-anim-joint-control-method-9 () none) ;; 9 ;; (reset (_type_) none 9)
|
|
(top-anim-joint-control-method-10 () none) ;; 10 ;; (update (_type_) none 10)
|
|
(top-anim-joint-control-method-11 () none) ;; 11 ;; (get-channel (_type_ int) joint-control-channel 11)
|
|
(top-anim-joint-control-method-12 () none) ;; 12 ;; (push-anim-to-targ (_type_ art-joint-anim float int int float float symbol) none 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-control (basic)
|
|
((status joint-control-status :offset-assert 4)
|
|
(allocated-length uint8 :offset-assert 6)
|
|
(active-channels uint8 :offset-assert 7)
|
|
(root-channel (inline-array joint-control-channel) :offset-assert 16) ;; guessed by decompiler
|
|
(blend-index uint8 :offset-assert 20)
|
|
(active-frame-interp uint8 :offset-assert 21)
|
|
(float-channels uint8 :offset-assert 22)
|
|
(generate-frame-function (function joint-anim-frame int joint-control int) :offset-assert 24) ;; guessed by decompiler
|
|
(prebind-function (function joint-anim-frame int joint-control int) :offset-assert 28) ;; guessed by decompiler
|
|
(postbind-function (function draw-control cspace-array joint-control none) :offset-assert 32) ;; guessed by decompiler
|
|
(effect effect-control :offset-assert 36) ;; guessed by decompiler
|
|
(interp-select int64 2 :offset-assert 40) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(top-anim top-anim-joint-control :offset-assert 56) ;; guessed by decompiler
|
|
(override (array float) :offset-assert 60) ;; guessed by decompiler
|
|
(channel joint-control-channel :dynamic :offset-assert 64) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x40
|
|
:flag-assert #xd00000040
|
|
;; field joint-control-status is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(joint-control-method-9 () none) ;; 9 ;; (current-cycle-distance (_type_) float 9)
|
|
(joint-control-method-10 () none) ;; 10 ;; (update-anim-data (_type_) none 10)
|
|
(joint-control-method-11 () none) ;; 11 ;; (debug-print-channels (_type_ symbol) int 11)
|
|
(joint-control-method-12 () none) ;; 12
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype matrix-stack (structure)
|
|
((top matrix :offset-assert 0)
|
|
(data matrix 24 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x610
|
|
:flag-assert #x900000610
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype channel-upload-info (structure)
|
|
((fixed joint-anim-compressed-fixed :offset-assert 0)
|
|
(fixed-qwc int32 :offset-assert 4)
|
|
(frame joint-anim-compressed-frame :offset-assert 8)
|
|
(frame-qwc int32 :offset-assert 12)
|
|
(amount float :offset-assert 16)
|
|
(interp float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-work (structure)
|
|
((temp-mtx matrix :inline :offset-assert 0)
|
|
(joint-stack matrix-stack :inline :offset-assert 64)
|
|
(fix-jmp-table (function none) 16 :offset-assert 1616) ;; guessed by decompiler
|
|
(frm-jmp-table (function none) 16 :offset-assert 1680) ;; guessed by decompiler
|
|
(pair-jmp-table (function none) 16 :offset-assert 1744) ;; guessed by decompiler
|
|
(uploads channel-upload-info 24 :offset-assert 1808) ;; guessed by decompiler
|
|
(num-uploads int32 :offset-assert 2384)
|
|
(mtx-acc matrix 2 :offset-assert 2400) ;; guessed by decompiler
|
|
(tq-acc transformq 100 :offset-assert 2528) ;; guessed by decompiler
|
|
(jacp-hdr joint-anim-compressed-hdr :inline :offset-assert 7328)
|
|
(fixed-data joint-anim-compressed-fixed :inline :offset-assert 7392)
|
|
(frame-data joint-anim-compressed-frame 2 :offset-assert 9600) ;; guessed by decompiler
|
|
(flatten-array float 576 :offset-assert 2400) ;; guessed by decompiler
|
|
(flattened vector 24 :offset-assert 2400) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3640
|
|
:flag-assert #x900003640
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bones-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bone-buffer (structure)
|
|
((joint matrix 16 :offset-assert 0) ;; guessed by decompiler
|
|
(bone bone 16 :offset-assert 1024) ;; guessed by decompiler
|
|
(output pris-mtx 16 :offset-assert 2304) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1100
|
|
:flag-assert #x900001100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone-layout (structure)
|
|
((data uint16 8 :offset-assert 0) ;; guessed by decompiler
|
|
(joint (inline-array matrix) 2 :offset-assert 0) ;; guessed by decompiler
|
|
(bone (inline-array bone) 2 :offset-assert 8) ;; guessed by decompiler
|
|
(output (inline-array pris-mtx) 2 :offset-assert 16) ;; guessed by decompiler
|
|
(unused uint32 2 :offset-assert 24) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone-regs (structure)
|
|
((dma-buf basic :offset-assert 0)
|
|
(wait-count uint32 :offset-assert 4)
|
|
(in-count uint32 :offset-assert 8)
|
|
(sp-size uint32 :offset-assert 12)
|
|
(sp-bufnum uint32 :offset-assert 16)
|
|
(joint-ptr (inline-array joint) :offset-assert 20) ;; guessed by decompiler
|
|
(bone-ptr (inline-array bone) :offset-assert 24) ;; guessed by decompiler
|
|
(num-bones uint32 :offset-assert 28)
|
|
(mtxs (inline-array pris-mtx) :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone-work (structure)
|
|
((layout bone-layout :inline :offset-assert 0)
|
|
(regs bone-regs :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone-debug (structure)
|
|
((time-ctr uint32 :offset-assert 0)
|
|
(timing uint32 360 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5a4
|
|
:flag-assert #x9000005a4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone-memory (structure)
|
|
((work bone-work :inline :offset-assert 0)
|
|
(buffer bone-buffer 2 :offset-assert 80) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2250
|
|
:flag-assert #x900002250
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone-calculation (structure)
|
|
((flags uint16 :offset-assert 0) ;; bone-calc-flags
|
|
(num-bones uint16 :offset-assert 2)
|
|
(matrix-area (inline-array pris-mtx) :offset-assert 4) ;; guessed by decompiler
|
|
(joints (inline-array joint) :offset-assert 8) ;; guessed by decompiler
|
|
(bones (inline-array bone) :offset-assert 12) ;; guessed by decompiler
|
|
(ripple-scale float :offset-assert 16)
|
|
(ripple-y-scale float :offset-assert 20)
|
|
(ripple-normal-scale float :offset-assert 24)
|
|
(ripple-area (inline-array vector) :offset-assert 28) ;; guessed by decompiler
|
|
(next bone-calculation :offset-assert 32)
|
|
(dummy-1 uint32 :offset-assert 36)
|
|
(dummy-2 uint32 :offset-assert 40)
|
|
(dummy-3 uint32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bone-calculation-list (structure)
|
|
((first bone-calculation :offset-assert 0)
|
|
(next bone-calculation :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; foreground-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mercneric-chain (structure)
|
|
((first uint32 :offset-assert 0)
|
|
(next uint32 :offset-assert 4)
|
|
(state generic-bucket-state :inline :offset-assert 8)
|
|
(vu1-bucket int32 :offset-assert 16) ;; bucket-id
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-chain (structure)
|
|
((first dma-packet :offset-assert 0)
|
|
(patch dma-packet :offset-assert 4)
|
|
(vu1-bucket int32 :offset-assert 8) ;; bucket-id
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype foreground-bucket (structure)
|
|
((merc merc-chain :inline :offset-assert 0)
|
|
(emerc merc-chain :inline :offset-assert 12)
|
|
(mercneric mercneric-chain :inline :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype foreground-level-buckets (structure)
|
|
((data foreground-bucket 7 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x150
|
|
:flag-assert #x900000150
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype foreground-bucket-grid (structure)
|
|
((level-buckets foreground-level-buckets 11 :offset-assert 0) ;; guessed by decompiler
|
|
(warp-chain mercneric-chain :inline :offset-assert 3696)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xe84
|
|
:flag-assert #x900000e84
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype foreground-regs (structure)
|
|
((dist float :offset-assert 0)
|
|
(merc-used uint32 :offset-assert 4)
|
|
(emerc-used uint32 :offset-assert 8)
|
|
(mercneric-used uint32 :offset-assert 12)
|
|
(use-isometric uint32 :offset-assert 16)
|
|
(base-start dma-packet :offset-assert 20)
|
|
(joint-ptr (inline-array joint) :offset-assert 24) ;; guessed by decompiler
|
|
(bone-ptr (inline-array bone) :offset-assert 28) ;; guessed by decompiler
|
|
(num-bones uint32 :offset-assert 32)
|
|
(mtxs (inline-array pris-mtx) :offset-assert 36) ;; guessed by decompiler
|
|
(dma-buf dma-buffer :offset-assert 40) ;; guessed by decompiler
|
|
(default-texture-index uint32 :offset-assert 44)
|
|
(mercneric-chain mercneric-chain :offset-assert 48)
|
|
(level-buckets foreground-level-buckets :offset-assert 52)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype foreground-work (structure)
|
|
((regs foreground-regs :inline :offset-assert 0)
|
|
(draw-index-map uint8 11 :offset-assert 64) ;; guessed by decompiler
|
|
(grid foreground-bucket-grid :inline :offset-assert 80)
|
|
(bounds sphere :inline :offset-assert 3808)
|
|
(lights vu-lights :inline :offset-assert 3824)
|
|
(distance vector :inline :offset-assert 3936)
|
|
(next-tmpl dma-packet :inline :offset-assert 3952)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf80
|
|
:flag-assert #x900000f80
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype texscroll-globals (structure)
|
|
((requests int32 :offset-assert 0)
|
|
(effects merc-effect 32 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x84
|
|
:flag-assert #x900000084
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-effect-bucket-info (structure)
|
|
((color-fade rgba :offset-assert 0) ;; guessed by decompiler
|
|
(merc-path uint8 :offset-assert 4)
|
|
(ignore-alpha uint8 :offset-assert 5)
|
|
(disable-draw uint8 :offset-assert 6)
|
|
(disable-envmap uint8 :offset-assert 7)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype merc-bucket-info (structure)
|
|
((light vu-lights :inline :offset-assert 0)
|
|
(needs-clip int32 :offset-assert 112)
|
|
(need-mercprime-if-merc int32 :offset-assert 116)
|
|
(must-use-mercneric-for-clip int32 :offset-assert 120)
|
|
(effect merc-effect-bucket-info 64 :offset-assert 124) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x27c
|
|
:flag-assert #x90000027c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype foreground-globals (structure)
|
|
((foreground-grid foreground-bucket-grid :inline :offset-assert 0)
|
|
(merc-bucket-info merc-bucket-info :inline :offset-assert 3728)
|
|
(texscroll texscroll-globals :inline :offset-assert 4368)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1194
|
|
:flag-assert #x900001194
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-dma-packet (structure)
|
|
((tag generic-merc-tag :inline :offset-assert 0)
|
|
(settings shadow-settings :inline :offset-assert 16)
|
|
(geo-ref dma-packet :inline :offset-assert 96)
|
|
(mtx-ref dma-packet :inline :offset-assert 112)
|
|
(end-tag dma-packet :inline :offset-assert 128)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
;; (define-extern invalidate-cache-line function) ;; (function pointer int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; engines ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype particle-local-space-info (connection)
|
|
((params UNKNOWN 3 :offset-assert 20)
|
|
(mat-prev matrix :inline :offset-assert 32)
|
|
(mat-new matrix :inline :offset-assert 96)
|
|
(hand uint64 :offset-assert 160)
|
|
(flags uint32 :offset-assert 168)
|
|
(pad UNKNOWN 1 :offset-assert 172)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #xb0
|
|
:flag-assert #xe000000b0
|
|
;; field param1 uses ~A with a signed load. field param2 uses ~A with a signed load. field param3 uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *background-draw-engine* object) ;; engine
|
|
;; (define-extern *matrix-engine* object) ;; (array handle)
|
|
;; (define-extern *cloth-engine* object)
|
|
;; (define-extern *part-engine* object) ;; engine
|
|
;; (define-extern *cam-post-hook-engine* object)
|
|
;; (define-extern *part-local-space-engine* object)
|
|
;; (define-extern *camera-engine* object) ;; engine
|
|
;; (define-extern *debug-engine* object) ;; engine
|
|
;; (define-extern *pad-engine* object) ;; engine
|
|
;; (define-extern *lightning-engine* object) ;; engine
|
|
;; (define-extern *hud-engine* object) ;; engine
|
|
;; (define-extern *prim-engine* object)
|
|
;; (define-extern *task-manager-engine* object) ;; engine
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyport-attack-bbush ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ctyport-attack-manager-bbush (ctyport-attack-manager)
|
|
((actor-group uint32 :offset-assert 308)
|
|
(actor-group-count int32 :offset-assert 312)
|
|
(clock-speed float :offset-assert 316)
|
|
(hud-timer uint64 :offset-assert 196)
|
|
(countdown-timer uint64 :offset-assert 332)
|
|
)
|
|
:method-count-assert 53
|
|
:size-assert #x158
|
|
:flag-assert #x3500e00158
|
|
(:state-methods
|
|
wait ;; 14
|
|
pickup-nukes ;; 32
|
|
head-to-wall ;; 33
|
|
wait-award ;; 52
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ctyport-attack-bbush-positions* object)
|
|
;; (define-extern *ctyport-bbush-mine-positions* array)
|
|
;; (define-extern *port-attack-bbush-fail-sphere* object)
|
|
;; (define-extern *port-attack-bbush-fail-radius* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; res-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype res-tag (uint128)
|
|
;; ()
|
|
;; :flag-assert #x900000010
|
|
;; )
|
|
|
|
#|
|
|
(deftype res-lump (basic)
|
|
((length int32 :offset-assert 4)
|
|
(allocated-length int16 :offset-assert 8) ;; int32
|
|
(flags uint16 :offset-assert 10)
|
|
(data-base pointer :offset-assert 12) ;; guessed by decompiler
|
|
(data-top pointer :offset-assert 16) ;; guessed by decompiler
|
|
(data-size int32 :offset-assert 20)
|
|
(extra entity-links :offset-assert 24) ;; guessed by decompiler
|
|
(tag (pointer res-tag) :offset-assert 28) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x20
|
|
:flag-assert #x1600000020
|
|
;; field extra uses ~A with a signed load.
|
|
(:methods
|
|
;; (new (symbol type int int) _type_ 0)
|
|
(res-lump-method-9 () none) ;; 9 ;; (get-property-data (_type_ symbol symbol float pointer (pointer res-tag) pointer) pointer 9)
|
|
(res-lump-method-10 () none) ;; 10 ;; (get-property-struct (_type_ symbol symbol float structure (pointer res-tag) pointer) structure 10)
|
|
(res-lump-method-11 () none) ;; 11 ;; (get-property-value (_type_ symbol symbol float uint128 (pointer res-tag) pointer) uint128 11)
|
|
(res-lump-method-12 () none) ;; 12 ;; (get-property-value-float (_type_ symbol symbol float float (pointer res-tag) pointer) float 12)
|
|
(res-lump-method-13 () none) ;; 13 ;; (get-tag-index-data (_type_ int) pointer 13)
|
|
(res-lump-method-14 () none) ;; 14 ;; (get-tag-data (_type_ res-tag) pointer 14)
|
|
(res-lump-method-15 () none) ;; 15 ;; (allocate-data-memory-for-tag! (_type_ res-tag) res-tag 15)
|
|
(res-lump-method-16 () none) ;; 16 ;; (sort! (_type_) _type_ 16)
|
|
(res-lump-method-17 () none) ;; 17 ;; (add-data! (_type_ res-tag pointer) res-lump 17)
|
|
(res-lump-method-18 () none) ;; 18 ;; (add-32bit-data! (_type_ res-tag object) res-lump 18)
|
|
(res-lump-method-19 () none) ;; 19 ;; (lookup-tag-idx (_type_ symbol symbol float) res-tag-pair 19)
|
|
(res-lump-method-20 () none) ;; 20 ;; (make-property-data (_type_ float res-tag-pair pointer) pointer 20)
|
|
(res-lump-method-21 () none) ;; 21 ;; (get-curve-data! (_type_ curve symbol symbol float) symbol 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *res-key-string* object) ;; string
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; texture-anim-tables ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sky-texture-anim-array* texture-anim-array) ;; (texture-anim-array texture-anim)
|
|
;; (define-extern set-fog-height! function) ;; (function float none)
|
|
;; (define-extern set-cloud-minmax! function) ;; (function float float none)
|
|
;; (define-extern *darkjak-texture-anim-array* texture-anim-array) ;; (texture-anim-array texture-anim)
|
|
;; (define-extern set-darkjak-texture-morph! function) ;; (function float none)
|
|
;; (define-extern *darkjak-highres-texture-anim-array* texture-anim-array)
|
|
;; (define-extern set-darkjak-highres-texture-morph! function) ;; (function float symbol)
|
|
;; (define-extern *skull-gem-texture-anim-array* texture-anim-array) ;; (texture-anim-array texture-anim)
|
|
;; (define-extern *default-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *default-warp-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; emerc-vu1 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern emerc-vu1-block object) ;; vu-function
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-util ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype kill-player-process (process)
|
|
((player uint64 :offset-assert 128)
|
|
(mode basic :offset-assert 136)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x8c
|
|
:flag-assert #x100010008c
|
|
(:state-methods
|
|
idle ;; 14
|
|
die ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern have-earned-vehicle-v-type? function)
|
|
;; (define-extern have-vehicle-v-type? function)
|
|
;; (define-extern kill-player-process-init-by-other function)
|
|
;; (define-extern kill-player-process-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; res ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; res-lump is already defined!
|
|
|
|
;; (define-extern *res-static-buf* object) ;; pointer
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; assault-path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *assault-rooms* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasstada-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wstd-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-arena-plat (base-plat)
|
|
((sync sync-paused :inline :offset-assert 272)
|
|
(flags uint64 :offset-assert 296)
|
|
(ride-timer uint64 :offset-assert 304)
|
|
(current-pos float :offset-assert 312)
|
|
(dest-pos float :offset-assert 316)
|
|
(speed float :offset-assert 320)
|
|
(y-pos float :offset-assert 324)
|
|
(ambient-sound-id uint32 :offset-assert 328)
|
|
(on-activate basic :offset-assert 332)
|
|
(go-pos float :offset-assert 336)
|
|
(sound-id uint32 :offset-assert 340)
|
|
(sound-running-loop basic :offset-assert 344)
|
|
)
|
|
:method-count-assert 45
|
|
:size-assert #x15c
|
|
:flag-assert #x2d00e0015c
|
|
;; field on-activate uses ~A with a signed load.
|
|
(:methods
|
|
(wstd-arena-plat-method-43 () none) ;; 43
|
|
(wstd-arena-plat-method-44 () none) ;; 44
|
|
)
|
|
(:state-methods
|
|
plat-base-state ;; 35
|
|
idle ;; 36
|
|
active ;; 37
|
|
run ;; 39
|
|
wait ;; 38
|
|
go-down ;; 42
|
|
wait-show ;; 41
|
|
show ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-flag-a (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-blocker (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype crowd-manager (process)
|
|
((crowd-intensity float :offset-assert 128)
|
|
(snd-id-1 uint32 :offset-assert 132)
|
|
(snd-id-2 uint32 :offset-assert 136)
|
|
(next-sound uint64 :offset-assert 144)
|
|
(channel uint32 :offset-assert 152)
|
|
(dur-sound uint64 :offset-assert 160)
|
|
(volume-1 float :offset-assert 168)
|
|
(volume-2 float :offset-assert 172)
|
|
(trans-1 vector :inline :offset-assert 176)
|
|
(trans-2 vector :inline :offset-assert 192)
|
|
(crowd-int-red float :offset-assert 208)
|
|
(trans vector :inline :offset-assert 224)
|
|
(training? basic :offset-assert 240)
|
|
(darkjak? basic :offset-assert 244)
|
|
(sid uint32 :offset-assert 248)
|
|
(volume float :offset-assert 252)
|
|
(snd-count uint32 :offset-assert 256)
|
|
(start-sound basic :offset-assert 260)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x108
|
|
:flag-assert #xf00900108
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *range-color-lava-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-lava-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-lava-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-lava-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-lava-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-lava-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-lava-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-lava-flame* curve2d-fast)
|
|
;; (define-extern *curve-scale-lava-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-scale-lava-flame-y* curve2d-fast)
|
|
;; (define-extern *part-wasstada-lava-flame-curve-settings* object)
|
|
;; (define-extern *crowd-manager* object)
|
|
;; (define-extern *crowd-positions* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lights ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *light-hash-work* object) ;; light-hash-work
|
|
;; (define-extern light-slerp function) ;; (function light light light float light)
|
|
;; (define-extern light-group-slerp function) ;; (function light-group light-group light-group float light-group)
|
|
;; (define-extern light-group-process! function) ;; (function vu-lights light-group vector vector none)
|
|
;; (define-extern *default-lights* object) ;; vu-lights
|
|
;; (define-extern vu-lights-default! function) ;; (function vu-lights vu-lights)
|
|
;; (define-extern init-light-hash function) ;; (function none)
|
|
;; (define-extern light-hash-count-items function) ;; (function light-hash light-sphere none)
|
|
;; (define-extern light-hash-add-items function) ;; (function light-hash light-sphere integer object)
|
|
;; (define-extern reset-light-hash function) ;; (function light-hash none)
|
|
;; (define-extern update-light-hash function) ;; (function light-hash none)
|
|
;; (define-extern lookup-light-sphere-by-name function) ;; (function string light-hash light-sphere)
|
|
;; (define-extern light-hash-get-bucket-index function) ;; (function light-hash vector int)
|
|
;; (define-extern add-light-sphere-to-light-group function) ;; (function object object object object object)
|
|
;; (define-extern light-merge! function)
|
|
;; (define-extern light-group-scale! function)
|
|
;; (define-extern light-group-madd! function)
|
|
;; (define-extern light-group-lerp! function)
|
|
;; (define-extern shadow-info-copy! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-merc ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype invinitdata (structure)
|
|
((count uint8 :offset-assert 0)
|
|
(init-data uint8 :offset-assert 1)
|
|
(init-addr uint16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern mercneric-vu0-block object) ;; vu-function
|
|
;; (define-extern *inv-init-table* object) ;; (inline-array invinitdata)
|
|
;; (define-extern generic-merc-init-asm function) ;; (function none)
|
|
;; (define-extern mercneric-matrix-asm function)
|
|
;; (define-extern mercneric-shader-asm function)
|
|
;; (define-extern mercneric-bittable-asm function)
|
|
;; (define-extern mercneric-convert function)
|
|
;; (define-extern high-speed-reject function)
|
|
;; (define-extern generic-translucent function) ;; (function gsf-buffer none)
|
|
;; (define-extern generic-merc-query function)
|
|
;; (define-extern generic-merc-death function)
|
|
;; (define-extern generic-merc-execute-asm function)
|
|
;; (define-extern generic-merc-do-chain function) ;; (function mercneric-chain dma-buffer pointer)
|
|
;; (define-extern generic-merc-execute-all function) ;; (function dma-buffer none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dynamics-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dynamics (basic)
|
|
((name symbol :offset-assert 4) ;; guessed by decompiler
|
|
(gravity-max meters :offset-assert 8)
|
|
(gravity-length meters :offset-assert 12)
|
|
(gravity vector :inline :offset-assert 16)
|
|
(gravity-normal vector :inline :offset-assert 32)
|
|
(walk-distance meters :offset-assert 48)
|
|
(run-distance meters :offset-assert 52)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x38
|
|
:flag-assert #xa00000038
|
|
(:methods
|
|
(dynamics-method-9 () none) ;; 9 ;; (set-gravity-length (_type_ float) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern time-to-apex function) ;; (function float float int)
|
|
;; (define-extern time-to-ground function) ;; (function float float float int)
|
|
;; (define-extern *standard-dynamics* dynamics) ;; dynamics
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; shield-sphere ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype shield-sphere-heat (structure)
|
|
((current-heat-value float :offset-assert 0)
|
|
(damage-scalar float :offset-assert 4)
|
|
(last-heat-time uint64 :offset-assert 8)
|
|
(distort-handle uint64 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shield-sphere-toggle (structure)
|
|
((enable-time uint64 :offset-assert 0)
|
|
(disable-time uint64 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shield-sphere (process-focusable)
|
|
((owner uint64 :offset-assert 208)
|
|
(sphere-size float :offset-assert 216)
|
|
(offset-vec vector :inline :offset-assert 224)
|
|
(enabled? basic :offset-assert 240)
|
|
(shield-type uint8 :offset-assert 244)
|
|
(track-joint int32 :offset-assert 248)
|
|
(heat-info shield-sphere-heat :inline :offset-assert 256)
|
|
(toggle-info shield-sphere-toggle :inline :offset-assert 256)
|
|
(last-attack-time uint64 :offset-assert 280)
|
|
(last-attack-id uint32 :offset-assert 288)
|
|
(persistent-attack-id uint32 :offset-assert 292)
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x128
|
|
:flag-assert #x2b00b00128
|
|
(:methods
|
|
(shield-sphere-method-32 () none) ;; 32
|
|
(shield-sphere-method-33 () none) ;; 33
|
|
(shield-sphere-method-34 () none) ;; 34
|
|
(shield-sphere-method-35 () none) ;; 35
|
|
(shield-sphere-method-36 () none) ;; 36
|
|
(shield-sphere-method-37 () none) ;; 37
|
|
(shield-sphere-method-38 () none) ;; 38
|
|
(shield-sphere-method-39 () none) ;; 39
|
|
(shield-sphere-method-40 () none) ;; 40
|
|
(shield-sphere-method-41 () none) ;; 41
|
|
(shield-sphere-method-42 () none) ;; 42
|
|
)
|
|
(:state-methods
|
|
shield-enabled ;; 28
|
|
shield-disabled ;; 29
|
|
explode ;; 30
|
|
die ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shield-sphere-spawn-params (structure)
|
|
((offset-vec vector :inline :offset-assert 0)
|
|
(owner uint64 :offset-assert 16)
|
|
(sphere-size float :offset-assert 24)
|
|
(shield-type uint8 :offset-assert 28)
|
|
(track-joint int32 :offset-assert 32)
|
|
(enable-time uint64 :offset-assert 40)
|
|
(disable-time uint64 :offset-assert 48)
|
|
(shield-strength int8 :offset-assert 56)
|
|
(pad int16 :offset-assert 58)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shield-sphere-distort (process-drawable)
|
|
((owner uint64 :offset-assert 200)
|
|
(sphere-size float :offset-assert 208)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd4
|
|
:flag-assert #x17006000d4
|
|
(:state-methods
|
|
die ;; 22
|
|
distort ;; 21
|
|
inactive ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shield-sphere-distort-spawn-params (structure)
|
|
((owner uint64 :offset-assert 0)
|
|
(sphere-size float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern shield-sphere-distort-init-by-other function)
|
|
;; (define-extern *shield-sphere-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern shield-sphere-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; decomp ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype huf-dictionary-node (structure)
|
|
((zero uint16 :offset-assert 0)
|
|
(one uint16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern unpack-comp-rle function) ;; (function (pointer int8) (pointer int8) (pointer int8))
|
|
;; (define-extern unpack-comp-huf function) ;; (function (pointer uint8) (pointer uint8) uint huf-dictionary-node none)
|
|
;; (define-extern unpack-comp-lzo function) ;; (function (pointer uint8) (pointer uint8) none)
|
|
;; (define-extern pack-comp-rle function) ;; (function (pointer uint8) (pointer uint8) int int (pointer uint8))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sky-data ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sky-work* object) ;; sky-work
|
|
;; (define-extern sky-base-polygons object) ;; (inline-array sky-vertex)
|
|
;; (define-extern sky-roof-polygons object) ;; (inline-array sky-vertex)
|
|
;; (define-extern *cloud-vert-array* object) ;; cloud-vert-array
|
|
;; (define-extern *cloud-poly* object) ;; (inline-array sky-vertex)
|
|
;; (define-extern init-cloud-vert-array function) ;; (function symbol)
|
|
;; (define-extern *haze-vert-array* object) ;; haze-vert-array
|
|
;; (define-extern *haze-poly* object) ;; (inline-array sky-vertex)
|
|
;; (define-extern init-haze-vert-array function) ;; (function symbol)
|
|
;; (define-extern sky-make-sun-data function) ;; (function sky-work int float none)
|
|
;; (define-extern sky-make-moon-data function) ;; (function sky-work float none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; surface-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype surface (basic)
|
|
((name symbol :offset-assert 4) ;; guessed by decompiler
|
|
(data float 30 :offset-assert 8) ;; guessed by decompiler
|
|
(turnv float :offset-assert 8)
|
|
(turnvf float :offset-assert 100)
|
|
(turnvv float :offset-assert 12)
|
|
(turnvvf float :offset-assert 104)
|
|
(tiltv float :offset-assert 16)
|
|
(tiltvf float :offset-assert 108)
|
|
(tiltvv float :offset-assert 20)
|
|
(tiltvvf float :offset-assert 112)
|
|
(vel-turn float :offset-assert 116)
|
|
(transv-max float :offset-assert 24)
|
|
(target-speed float :offset-assert 28)
|
|
(seek0 float :offset-assert 32)
|
|
(seek90 float :offset-assert 36)
|
|
(seek180 float :offset-assert 40)
|
|
(fric float :offset-assert 44)
|
|
(nonlin-fric-dist float :offset-assert 48)
|
|
(slip-factor float :offset-assert 52)
|
|
(slide-factor float :offset-assert 56)
|
|
(slope-up-factor float :offset-assert 60)
|
|
(slope-down-factor float :offset-assert 64)
|
|
(slope-slip-angle float :offset-assert 68)
|
|
(impact-fric float :offset-assert 72)
|
|
(bend-factor float :offset-assert 76)
|
|
(bend-speed float :offset-assert 80)
|
|
(alignv float :offset-assert 84)
|
|
(slope-up-traction float :offset-assert 88)
|
|
(align-speed float :offset-assert 92)
|
|
(slope-change-preserve float :offset-assert 96)
|
|
(hook function 5 :offset-assert 128) ;; guessed by decompiler
|
|
(active-hook (function none) :offset-assert 128) ;; guessed by decompiler
|
|
(touch-hook (function none) :offset-assert 132) ;; guessed by decompiler
|
|
(impact-hook (function control-info (pointer float) vector none) :offset-assert 136) ;; guessed by decompiler
|
|
(mult-hook (function surface surface surface int none) :offset-assert 140) ;; guessed by decompiler
|
|
(exit-hook function :offset-assert 144) ;; guessed by decompiler
|
|
(dataw uint32 2 :offset-assert 148) ;; guessed by decompiler
|
|
(mode symbol :offset-assert 148) ;; guessed by decompiler
|
|
(flags surface-flag :offset-assert 152)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x9c
|
|
:flag-assert #x90000009c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern calc-terminal-vel function) ;; (function float float float float)
|
|
;; (define-extern calc-terminal2-vel function) ;; (function float float float float float)
|
|
;; (define-extern calc-terminal4-vel function) ;; (function float float float float)
|
|
;; (define-extern surface-interp! function) ;; (function surface surface surface float surface)
|
|
;; (define-extern surface-mult! function) ;; (function surface surface surface surface)
|
|
;; (define-extern surface-clamp-speed function) ;; (function surface surface surface int none)
|
|
;; (define-extern *walk-mods* surface) ;; surface
|
|
;; (define-extern *walk-no-turn-mods* surface) ;; surface
|
|
;; (define-extern *turn-around-mods* surface) ;; surface
|
|
;; (define-extern *jump-mods* surface) ;; surface
|
|
;; (define-extern *double-jump-mods* surface) ;; surface
|
|
;; (define-extern *smack-jump-mods* surface) ;; surface
|
|
;; (define-extern *high-jump-mods* surface) ;; surface
|
|
;; (define-extern *launch-jump-mods* surface) ;; surface
|
|
;; (define-extern *forward-high-jump-mods* surface) ;; surface
|
|
;; (define-extern *flip-jump-mods* surface) ;; surface
|
|
;; (define-extern *forward-jump-mods* surface) ;; surface
|
|
;; (define-extern *forward-pole-jump-mods* surface) ;; surface
|
|
;; (define-extern *dark-jump-mods* object) ;; surface
|
|
;; (define-extern *roll-mods* surface) ;; surface
|
|
;; (define-extern *roll-flip-mods* surface) ;; surface
|
|
;; (define-extern *flop-mods* surface) ;; surface
|
|
;; (define-extern *flop-land-mods* object) ;; surface
|
|
;; (define-extern *wade-mods* surface) ;; surface
|
|
;; (define-extern *swim-mods* surface) ;; surface
|
|
;; (define-extern *dive-mods* surface) ;; surface
|
|
;; (define-extern *dive-bottom-mods* surface) ;; surface
|
|
;; (define-extern *pole-mods* object) ;; surface
|
|
;; (define-extern *grab-mods* object) ;; surface
|
|
;; (define-extern *edge-grab-mods* object) ;; surface
|
|
;; (define-extern *empty-mods* surface) ;; surface
|
|
;; (define-extern *empty-mods-allow-gun* surface)
|
|
;; (define-extern *neutral-mods* surface) ;; surface
|
|
;; (define-extern *stone-surface* surface) ;; surface
|
|
;; (define-extern *mushroom-surface* surface)
|
|
;; (define-extern *gravel-surface* surface) ;; surface
|
|
;; (define-extern *edge-surface* surface) ;; surface
|
|
;; (define-extern *wade-surface* surface) ;; surface
|
|
;; (define-extern *quicksand-surface* surface) ;; surface
|
|
;; (define-extern *tar-surface* surface) ;; surface
|
|
;; (define-extern *ice-surface* surface) ;; surface
|
|
;; (define-extern *rail-surface* surface) ;; surface
|
|
;; (define-extern *standard-ground-surface* object) ;; surface
|
|
;; (define-extern *swim-surface* object) ;; surface
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pat-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pat-surface (uint32)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pat-mode-info (structure)
|
|
((name string :offset-assert 0) ;; guessed by decompiler
|
|
(wall-angle float :offset-assert 4)
|
|
(color rgba :offset-assert 8) ;; guessed by decompiler
|
|
(hilite-color rgba :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern pat-material->string function) ;; (function pat-surface string)
|
|
;; (define-extern pat-mode->string function) ;; (function pat-surface string)
|
|
;; (define-extern pat-event->string function) ;; (function pat-surface string)
|
|
;; (define-extern *pat-mode-info* object) ;; (inline-array pat-mode-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fact-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fact-bank (basic)
|
|
((eco-level-max float :offset-assert 4)
|
|
(eco-single-inc float :offset-assert 8)
|
|
(eco-full-inc float :offset-assert 12)
|
|
(eco-single-timeout seconds :offset-assert 16)
|
|
(eco-full-timeout seconds :offset-assert 24)
|
|
(dummy seconds :offset-assert 32)
|
|
(health-max-default float :offset-assert 40)
|
|
(health-max-max float :offset-assert 44)
|
|
(health-small-inc float :offset-assert 48)
|
|
(health-single-inc float :offset-assert 52)
|
|
(health-default-inc float :offset-assert 56)
|
|
(health-darkjak-inc float :offset-assert 60)
|
|
(health-darkjak-min float :offset-assert 64)
|
|
(health-darkjak-error float :offset-assert 68)
|
|
(eco-pill-green-max-default float :offset-assert 72)
|
|
(eco-pill-dark-max-default float :offset-assert 76)
|
|
(eco-pill-light-max-default float :offset-assert 80)
|
|
(eco-green-max-default float :offset-assert 84)
|
|
(default-eco-pill-green-inc float :offset-assert 88)
|
|
(default-eco-pill-dark-inc float :offset-assert 92)
|
|
(default-eco-pill-light-inc float :offset-assert 96)
|
|
(buzzer-max-default float :offset-assert 100)
|
|
(buzzer-single-inc float :offset-assert 104)
|
|
(suck-bounce-dist meters :offset-assert 108)
|
|
(suck-suck-dist meters :offset-assert 112)
|
|
(ammo-yellow-max float :offset-assert 116)
|
|
(ammo-red-max float :offset-assert 120)
|
|
(ammo-blue-max float :offset-assert 124)
|
|
(ammo-dark-max float :offset-assert 128)
|
|
(ammo-yellow-start float :offset-assert 132)
|
|
(ammo-red-start float :offset-assert 136)
|
|
(ammo-blue-start float :offset-assert 140)
|
|
(ammo-dark-start float :offset-assert 144)
|
|
(shield-max float :offset-assert 148)
|
|
(shield-use-speed float :offset-assert 152)
|
|
(shield-time-min seconds :offset-assert 160)
|
|
(trick-point-max float :offset-assert 168)
|
|
(super-skill-inc float :offset-assert 172)
|
|
(lightjak-regen-inc float :offset-assert 176)
|
|
(lightjak-swoop-inc float :offset-assert 180)
|
|
(lightjak-freeze-inc float :offset-assert 184)
|
|
(lightjak-freeze-min float :offset-assert 188)
|
|
(lightjak-freeze-duration seconds :offset-assert 192)
|
|
(lightjak-shield-inc float :offset-assert 200)
|
|
(lightjak-shield-hit-inc float :offset-assert 204)
|
|
(darkjak-spin-inc float :offset-assert 208)
|
|
(darkjak-punch-inc float :offset-assert 212)
|
|
(darkjak-flop-inc float :offset-assert 216)
|
|
(darkjak-uppercut-inc float :offset-assert 220)
|
|
(darkjak-bomb0-inc float :offset-assert 224)
|
|
(darkjak-bomb1-inc float :offset-assert 228)
|
|
(darkjak-smack-inc float :offset-assert 232)
|
|
(darkjak-bomb-min float :offset-assert 236)
|
|
(darkjak-button-invis-inc float :offset-assert 240)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf4
|
|
:flag-assert #x9000000f4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fact-info (basic)
|
|
((process process :offset-assert 4) ;; guessed by decompiler
|
|
(pickup-amount float :offset-assert 12)
|
|
(pickup-spawn-amount float :offset-assert 16)
|
|
(options actor-option :offset-assert 24)
|
|
(fade-time uint64 :offset-assert 32) ;; time-frame
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x28
|
|
:flag-assert #xc00000028
|
|
;; field actor-option is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type process pickup-type float) _type_ 0)
|
|
(fact-info-method-9 () none) ;; 9 ;; (drop-pickup (_type_ symbol process-tree fact-info int) (pointer process) 9)
|
|
(fact-info-method-10 () none) ;; 10 ;; (reset! (_type_ symbol) none 10)
|
|
(fact-info-method-11 () none) ;; 11 ;; (pickup-collectable! (_type_ pickup-type float handle) float 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fact-info-target (fact-info)
|
|
((process process :offset-assert 0) ;; guessed by decompiler
|
|
(pickup-amount float :offset-assert 8)
|
|
(pickup-spawn-amount float :offset-assert 12)
|
|
(options actor-option :offset-assert 20)
|
|
(fade-time uint64 :offset-assert 28) ;; time-frame
|
|
(eco-type int32 :offset-assert 36)
|
|
(eco-level float :offset-assert 40)
|
|
(eco-pickup-time uint64 :offset-assert 44) ;; time-frame
|
|
(eco-timeout seconds :offset-assert 52) ;; time-frame
|
|
(eco-source uint64 :offset-assert 60) ;; handle
|
|
(eco-source-time uint64 :offset-assert 68) ;; time-frame
|
|
(health float :offset-assert 76)
|
|
(health-max float :offset-assert 80)
|
|
(health-pickup-time uint64 :offset-assert 84) ;; time-frame
|
|
(buzzer float :offset-assert 92)
|
|
(buzzer-max float :offset-assert 96)
|
|
(eco-pill-green float :offset-assert 100)
|
|
(eco-pill-green-max float :offset-assert 104)
|
|
(eco-pill-green-pickup-time uint64 :offset-assert 108) ;; time-frame
|
|
(eco-pill-dark-pickup-time uint64 :offset-assert 116) ;; time-frame
|
|
(eco-pill-light-pickup-time uint64 :offset-assert 124)
|
|
(money-pickup-time uint64 :offset-assert 132) ;; time-frame
|
|
(buzzer-pickup-time uint64 :offset-assert 140) ;; time-frame
|
|
(task-pickup-time uint64 :offset-assert 148) ;; time-frame
|
|
(stop-time-timeout uint64 :offset-assert 156) ;; time-frame
|
|
(darkjak-start-time uint64 :offset-assert 164) ;; time-frame
|
|
(darkjak-effect-time uint64 :offset-assert 172) ;; time-frame
|
|
(lightjak-start-time uint64 :offset-assert 180)
|
|
(lightjak-effect-time uint64 :offset-assert 188)
|
|
(ammo-pickup-time uint64 :offset-assert 196) ;; time-frame
|
|
(shield-pickup-time uint64 :offset-assert 204) ;; time-frame
|
|
(shield-start-time uint64 :offset-assert 212) ;; time-frame
|
|
(shield-use-time uint64 :offset-assert 220) ;; time-frame
|
|
(shield-level float :offset-assert 228)
|
|
(shield-attack-id uint32 :offset-assert 232)
|
|
(trick-point float :offset-assert 236)
|
|
(trick-point-pickup-time uint64 :offset-assert 244) ;; time-frame
|
|
(trick-point-start-time uint64 :offset-assert 252) ;; time-frame
|
|
(trick-point-duration uint64 :offset-assert 260) ;; time-frame
|
|
(gem-pickup-time uint64 :offset-assert 268) ;; time-frame
|
|
(skill-pickup-time uint64 :offset-assert 276) ;; time-frame
|
|
(karma-pickup-time uint64 :offset-assert 284) ;; time-frame
|
|
(eco-green float :offset-assert 292)
|
|
(eco-green-max float :offset-assert 296)
|
|
(eco-green-pickup-time uint64 :offset-assert 300)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x138
|
|
:flag-assert #xd00000138
|
|
;; field actor-option is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type process-drawable pickup-type float) _type_ 0)
|
|
(fact-info-target-method-12 () none) ;; 12 ;; (get-gun-ammo (_type_) float 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fact-info-enemy (fact-info)
|
|
((process process :offset-assert 0) ;; guessed by decompiler
|
|
(pickup-amount float :offset-assert 8)
|
|
(pickup-spawn-amount float :offset-assert 12)
|
|
(options actor-option :offset-assert 20)
|
|
(fade-time uint64 :offset-assert 28) ;; time-frame
|
|
(speed float :offset-assert 36)
|
|
(idle-distance meters :offset-assert 40)
|
|
(notice-top meters :offset-assert 44)
|
|
(notice-bottom meters :offset-assert 48)
|
|
(cam-horz meters :offset-assert 52)
|
|
(cam-vert meters :offset-assert 56)
|
|
(cam-notice-dist meters :offset-assert 60)
|
|
(enemy-options enemy-option :offset-assert 64)
|
|
(trig-dist meters :offset-assert 68)
|
|
(trig-actor-group (pointer actor-group) :offset-assert 72) ;; guessed by decompiler
|
|
(trig-mask-count int8 :offset-assert 76)
|
|
(trig-mask uint8 2 :offset-assert 77) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x53
|
|
:flag-assert #xd00000053
|
|
;; field actor-option is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type process (pointer float) pickup-type float) _type_ 0)
|
|
(fact-info-enemy-method-12 () none) ;; 12 ;; (clear-mask-bits (_type_ int) none 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fact-info-crate (fact-info)
|
|
((process process :offset-assert 0) ;; guessed by decompiler
|
|
(pickup-amount float :offset-assert 8)
|
|
(pickup-spawn-amount float :offset-assert 12)
|
|
(options actor-option :offset-assert 20)
|
|
(fade-time uint64 :offset-assert 28) ;; time-frame
|
|
(suck-count int32 :offset-assert 36)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x2c
|
|
:flag-assert #xc0000002c
|
|
;; field actor-option is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type process pickup-type float) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fact-info-enemy-defaults (basic)
|
|
((idle-distance meters :offset-assert 4)
|
|
(pickup-type int32 :offset-assert 8)
|
|
(pickup-amount float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *FACT-bank* fact-bank) ;; fact-bank
|
|
;; (define-extern pickup-type->string function) ;; (function pickup-type string)
|
|
;; (define-extern *fact-info-enemy-defaults* fact-info-enemy-defaults) ;; fact-info-enemy-defaults
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; aligner-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype align-control (basic)
|
|
((flags align-flags :offset-assert 4) ;; guessed by decompiler
|
|
(process process-drawable :offset-assert 8) ;; guessed by decompiler
|
|
(frame-group art-joint-anim :offset-assert 12) ;; guessed by decompiler
|
|
(frame-num float :offset-assert 16)
|
|
(matrix matrix 2 :offset-assert 32) ;; guessed by decompiler
|
|
(transform transform 2 :offset-assert 160) ;; guessed by decompiler
|
|
(delta transformq :inline :offset-assert 256)
|
|
(last-speed meters :offset-assert 304)
|
|
(align transformq :inline :offset-assert 160)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x134
|
|
:flag-assert #xe00000134
|
|
(:methods
|
|
;; (new (symbol type process) _type_ 0)
|
|
(align-control-method-9 () none) ;; 9 ;; (compute-alignment! (_type_) transformq 9)
|
|
(align-control-method-10 () none) ;; 10 ;; (align! (_type_ align-opts float float float) trsqv 10)
|
|
(align-control-method-11 () none) ;; 11 ;; (align-vel-and-quat-only! (_type_ align-opts vector int float float) trsqv 11)
|
|
(align-control-method-12 () none) ;; 12 ;; (first-transform (_type_) transform 12)
|
|
(align-control-method-13 () none) ;; 13 ;; (second-transform (_type_) transform 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; find-nearest-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; penetrate-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern penetrate->string function)
|
|
;; (define-extern penetrate-using->damage function) ;; (function penetrate int)
|
|
;; (define-extern penetrated-by-all&hit-points->penetrated-by function) ;; (function penetrate int penetrate)
|
|
;; (define-extern pu->knocked-type function) ;; (function penetrate knocked-type)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; script-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype script-form (structure)
|
|
((name symbol :offset-assert 0) ;; guessed by decompiler
|
|
(spec pair :offset-assert 4) ;; guessed by decompiler
|
|
(func (function script-context object) :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xc
|
|
:flag-assert #xa0000000c
|
|
(:methods
|
|
(script-form-method-9 () none) ;; 9 ;; (script-form-method-9 () none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype script-context (structure)
|
|
((load-state load-state :offset-assert 0) ;; guessed by decompiler
|
|
(key object :offset-assert 4) ;; guessed by decompiler
|
|
(process process :offset-assert 8) ;; guessed by decompiler
|
|
(trans vector :offset-assert 12)
|
|
(side-effect? symbol :offset-assert 16) ;; guessed by decompiler
|
|
(got-error? symbol :offset-assert 20) ;; guessed by decompiler
|
|
(expr pair :offset-assert 24) ;; guessed by decompiler
|
|
(param-count int32 :offset-assert 28)
|
|
(param object 16 :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(param-type object 16 :offset-assert 96) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #xa0
|
|
:flag-assert #xc000000a0
|
|
;; field key uses ~A with a signed load. field expr uses ~A with a signed load.
|
|
(:methods
|
|
;; (new (symbol type object process vector) _type_ 0)
|
|
(script-context-method-9 () none) ;; 9 ;; (eval! (_type_ pair) object 9)
|
|
(script-context-method-10 () none) ;; 10 ;; (script-context-method-10 (_type_ object pair) object 10)
|
|
(script-context-method-11 () none) ;; 11 ;; (script-context-method-11 (_type_ pair pair symbol) symbol 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-debug ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype col-rend-filter (structure)
|
|
((show-pat-set pat-surface :offset-assert 0) ;; guessed by decompiler
|
|
(show-pat-clear pat-surface :offset-assert 4) ;; guessed by decompiler
|
|
(event-mask uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern col-rend-draw function) ;; (function col-rend col-rend-filter none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; progress-static ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-scene-info (basic)
|
|
((name string :offset-assert 4) ;; guessed by decompiler
|
|
(continue string :offset-assert 8) ;; guessed by decompiler
|
|
(info object :offset-assert 12) ;; guessed by decompiler
|
|
(text text-id :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
;; field info uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *main-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *main-options-debug* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *main-kiosk-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *main-demo-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *main-demo-shared-options* menu-option-list)
|
|
;; (define-extern *title* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *title-secret* menu-option-list)
|
|
;; (define-extern *unlocked-secrets* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *options-options* menu-option-list)
|
|
;; (define-extern *language-options* menu-option-list)
|
|
;; (define-extern *game-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *game-options-demo* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *graphic-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *graphic-title-options-pal* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *sound-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *picture-options* menu-option-list)
|
|
;; (define-extern *camera-options* menu-option-list)
|
|
;; (define-extern *quit-restart-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *load-save-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *save-options-title* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *loading-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *insufficient-space-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *hero-mode-message-options* menu-option-list)
|
|
;; (define-extern *secrets-insufficient-space-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *insert-card-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *error-loading-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *error-auto-saving-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *card-removed-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *error-disc-removed-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *error-reading-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *icon-info-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *format-card-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *already-exists-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *create-game-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *video-mode-warning-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *video-mode-ok-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *progressive-mode-warning-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *progressive-mode-ok-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *select-start-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *select-scene-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *bigmap-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *missions-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *highscores-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *controls-options* menu-option-list)
|
|
;; (define-extern *secret-options* menu-option-list) ;; menu-option-list
|
|
;; (define-extern *language-name-remap* array) ;; (array text-id)
|
|
;; (define-extern *audio-language-remap* array)
|
|
;; (define-extern *stereo-mode-name-remap* array) ;; (array text-id)
|
|
;; (define-extern *hud-ring-graphic-remap* array) ;; (array uint64)
|
|
;; (define-extern *hud-ring-kiosk-graphic-remap* array) ;; (array uint64)
|
|
;; (define-extern *hud-ring-demo-graphic-remap* array) ;; (array uint64)
|
|
;; (define-extern *hud-ring-demo-shared-graphic-remap* array)
|
|
;; (define-extern *hud-select-scene-act1* array) ;; (array hud-scene-info)
|
|
;; (define-extern *hud-select-scene-act2* array) ;; (array hud-scene-info)
|
|
;; (define-extern *hud-select-scene-act3* array) ;; (array hud-scene-info)
|
|
;; (define-extern *hud-select-scene-commentary* array)
|
|
;; (define-extern *progress-icon-arrays* array)
|
|
;; (define-extern *inventory* menu-option-list)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; title-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype title-control (process)
|
|
((selected int32 :offset-assert 124)
|
|
(sprites hud-sprite 2 :offset-assert 140) ;; guessed by decompiler
|
|
(sprite-pos vector :inline :offset-assert 268)
|
|
(sprite-draw uint32 :offset-assert 284)
|
|
(buffer external-art-buffer 2 :offset-assert 288) ;; guessed by decompiler
|
|
(want int32 2 :offset-assert 296) ;; guessed by decompiler
|
|
(want-name string 2 :offset-assert 304) ;; guessed by decompiler
|
|
(have int32 2 :offset-assert 312) ;; guessed by decompiler
|
|
(draw int32 :offset-assert 320)
|
|
(draw-name string :offset-assert 324) ;; guessed by decompiler
|
|
(active symbol :offset-assert 328) ;; guessed by decompiler
|
|
(spark-time uint64 :offset-assert 332) ;; time-frame
|
|
(gui-id sound-id :offset-assert 340) ;; guessed by decompiler
|
|
(logo uint32 :offset-assert 344)
|
|
)
|
|
:method-count-assert 19
|
|
:size-assert #x160
|
|
:flag-assert #x1300e00160
|
|
(:state-methods
|
|
startup ;; 14, old: (startup () _type_ :state 14)
|
|
wait ;; 15, old: (wait () _type_ :state 15)
|
|
idle ;; 16, old: (idle () _type_ :state 16)
|
|
scrap-book ;; 17, old: (scrap-book (int) _type_ :state 17)
|
|
control-spec ;; 18
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype museum-char (structure)
|
|
((skel basic :offset-assert 0)
|
|
(anim uint32 :offset-assert 4)
|
|
(height-min float :offset-assert 8)
|
|
(height-max float :offset-assert 12)
|
|
(zoom-min float :offset-assert 16)
|
|
(zoom-max float :offset-assert 20)
|
|
(scale float :offset-assert 24)
|
|
(text-id uint32 :offset-assert 28)
|
|
(cloth-reset-time uint64 :offset-assert 32)
|
|
(use-orient-cloth-reset? basic :offset-assert 40)
|
|
(outtake-num uint32 :offset-assert 44)
|
|
(outtake basic :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hirez-viewer (process-drawable)
|
|
((angley float :offset-assert 200)
|
|
(anglex float :offset-assert 204)
|
|
(updown float :offset-assert 208)
|
|
(zoom float :offset-assert 212)
|
|
(char museum-char :offset-assert 216)
|
|
(pos-x float :offset-assert 220)
|
|
(dest-pos-x float :offset-assert 224)
|
|
(alpha float :offset-assert 228)
|
|
(cloth-reset-time uint64 :offset-assert 232)
|
|
(use-orient-cloth-reset? basic :offset-assert 240)
|
|
(id uint32 :offset-assert 244)
|
|
(credits basic :offset-assert 248)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xfc
|
|
:flag-assert #x15008000fc
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype highres-viewer-manager (process)
|
|
((current int32 :offset-assert 128)
|
|
(next int32 :offset-assert 132)
|
|
(handle uint64 :offset-assert 136)
|
|
(left-right basic :offset-assert 144)
|
|
(museum basic :offset-assert 148)
|
|
(next-time uint64 :offset-assert 152)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xa0
|
|
:flag-assert #x10002000a0
|
|
(:state-methods
|
|
idle ;; 14
|
|
credits ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern title-screen-change function) ;; (function string int string int symbol symbol none :behavior title-control)
|
|
;; (define-extern wait-for-press function) ;; (function time-frame time-frame symbol symbol)
|
|
;; (define-extern direction-press function)
|
|
;; (define-extern title-menu function) ;; (function object :behavior title-control)
|
|
;; (define-extern title-fade-out function) ;; (function float none)
|
|
;; (define-extern title-progress function) ;; (function symbol none)
|
|
;; (define-extern *scrap-book-1* array)
|
|
;; (define-extern *scrap-book-2* array)
|
|
;; (define-extern title-control-init function) ;; (function none :behavior title-control)
|
|
;; (define-extern hirez-viewer-init-by-other function)
|
|
;; (define-extern spawn-hirez-viewer function)
|
|
;; (define-extern *museum-1* array)
|
|
;; (define-extern *museum-2* array)
|
|
;; (define-extern *museum-3* array)
|
|
;; (define-extern hvm-init-by-other function)
|
|
;; (define-extern spawn-hirez-viewer-manager function)
|
|
;; (define-extern draw-end-credits function) ;; (function level float symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; scene-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype scene-actor (basic)
|
|
((name string :offset-assert 4) ;; guessed by decompiler
|
|
(level symbol :offset-assert 8) ;; guessed by decompiler
|
|
(art-group string :offset-assert 12) ;; guessed by decompiler
|
|
(prefix string :offset-assert 16) ;; guessed by decompiler
|
|
(draw-frames pair :offset-assert 20) ;; guessed by decompiler
|
|
(scissor-frames pair :offset-assert 24) ;; guessed by decompiler
|
|
(shadow-frames basic :offset-assert 28)
|
|
(cloth-reset-frames basic :offset-assert 32)
|
|
(cloth-commands basic :offset-assert 36)
|
|
(camera int16 :offset-assert 40)
|
|
(light-index uint8 :offset-assert 42)
|
|
(shadow-mask uint8 :offset-assert 43)
|
|
(shadow-values uint32 :offset-assert 44)
|
|
(flags uint32 :offset-assert 48)
|
|
(command-list basic :offset-assert 52)
|
|
(shadow-flags int32 :offset-assert 56)
|
|
(shadow-volume-joint basic :offset-assert 60)
|
|
(draw-seg uint64 :offset-assert 64)
|
|
(no-draw-seg uint64 :offset-assert 72)
|
|
(last-frame float :offset-assert 80)
|
|
(process uint64 :offset-assert 88) ;; handle
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x60
|
|
:flag-assert #xa00000060
|
|
(:methods
|
|
(scene-actor-method-9 () none) ;; 9 ;; (scene-actor-method-9 (_type_ scene-player) (pointer process) 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype scene (art-group)
|
|
((name string :offset-assert 8) ;; guessed by decompiler
|
|
(length int32 :offset-assert 12)
|
|
(extra res-lump :offset-assert 16) ;; guessed by decompiler
|
|
(info file-info :offset-assert 4) ;; guessed by decompiler
|
|
(data art-element :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
(scene-flags uint32 :offset-assert 32)
|
|
(mask-to-clear process-mask :offset-assert 36) ;; guessed by decompiler
|
|
(entity string :offset-assert 40) ;; guessed by decompiler
|
|
(art-group string :offset-assert 44) ;; guessed by decompiler
|
|
(anim string :offset-assert 48) ;; guessed by decompiler
|
|
(parts int32 :offset-assert 52)
|
|
(command-list pair :offset-assert 56) ;; guessed by decompiler
|
|
(cut-list pair :offset-assert 60) ;; guessed by decompiler
|
|
(wait-max-time uint64 :offset-assert 64) ;; time-frame
|
|
(wait-air-time uint64 :offset-assert 72) ;; time-frame
|
|
(wait-ground-time uint64 :offset-assert 80) ;; time-frame
|
|
(actor (array scene-actor) :offset-assert 88) ;; guessed by decompiler
|
|
(load-point continue-point :offset-assert 92) ;; guessed by decompiler
|
|
(end-point continue-point :offset-assert 96) ;; guessed by decompiler
|
|
(borrow pair :offset-assert 100) ;; guessed by decompiler
|
|
(sfx-volume float :offset-assert 104)
|
|
(ambient-volume float :offset-assert 108)
|
|
(music-volume float :offset-assert 112)
|
|
(music-delay float :offset-assert 116)
|
|
(scene-task uint16 :offset-assert 120)
|
|
(on-running basic :offset-assert 124)
|
|
(on-complete basic :offset-assert 128)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x84
|
|
:flag-assert #x1200000084
|
|
;; field on-running uses ~A with a signed load. field on-complete uses ~A with a signed load.
|
|
(:methods
|
|
(scene-method-16 () none) ;; 16 ;; (scene-method-16 (_type_) _type_ 16)
|
|
(scene-method-17 () none) ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype scene-player (process-drawable)
|
|
((scene-list (array scene) :offset-assert 200) ;; guessed by decompiler
|
|
(scene scene :offset-assert 204) ;; guessed by decompiler
|
|
(scene-index int32 :offset-assert 208)
|
|
(anim spool-anim :offset-assert 212) ;; guessed by decompiler
|
|
(next-anim spool-anim :offset-assert 216) ;; guessed by decompiler
|
|
(camera uint64 :offset-assert 224) ;; handle
|
|
(main-entity entity-actor :offset-assert 232) ;; guessed by decompiler
|
|
(wait symbol :offset-assert 236) ;; guessed by decompiler
|
|
(old-target-pos transformq :inline :offset-assert 240)
|
|
(pre-cut-frame basic :offset-assert 288)
|
|
(preload-continue string :offset-assert 292) ;; guessed by decompiler
|
|
(preload-sound basic :offset-assert 296)
|
|
(dma-max uint32 :offset-assert 300)
|
|
(gui-id sound-id :offset-assert 304) ;; guessed by decompiler
|
|
(aborted? symbol :offset-assert 308) ;; guessed by decompiler
|
|
(scene-start-time uint64 :offset-assert 312) ;; time-frame
|
|
(targ-speed float :offset-assert 320)
|
|
(cur-speed float :offset-assert 324)
|
|
(speed-change-time uint64 :offset-assert 328) ;; time-frame
|
|
(speed-press-time uint64 :offset-assert 336) ;; time-frame
|
|
(speed-change-speed float :offset-assert 344)
|
|
(subtitle-change-time uint64 :offset-assert 352) ;; time-frame
|
|
(user-sound sound-id 4 :offset-assert 360) ;; guessed by decompiler
|
|
(last-frame float :offset-assert 376)
|
|
(end-point basic :offset-assert 380)
|
|
(blackout-end basic :offset-assert 384)
|
|
(new-trans-hook basic :offset-assert 388)
|
|
(cur-trans-hook basic :offset-assert 392)
|
|
(user-data uint64 :offset-assert 400)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x198
|
|
:flag-assert #x1a01200198
|
|
;; field user-data uses ~A with a 64-bit load.
|
|
(:methods
|
|
(scene-player-method-20 () none) ;; 20 ;; (wait (symbol) _type_ :state 20)
|
|
(scene-player-method-21 () none) ;; 21 ;; (release () _type_ :state 21)
|
|
(scene-player-method-22 () none) ;; 22 ;; (play-anim () _type_ :state 22)
|
|
(scene-player-method-23 () none) ;; 23 ;; (scene-player-method-23 (_type_ string symbol) none 23)
|
|
(scene-player-method-24 () none) ;; 24 ;; (scene-player-method-24 (_type_ basic symbol) scene 24)
|
|
(scene-player-method-25 () none) ;; 25 ;; (scene-player-method-25 (_type_ float) none 25)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *scene-player* object) ;; (pointer scene-player)
|
|
;; (define-extern *debug-menu-scene-play* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kleever-rider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype kleever-rider (process-focusable)
|
|
((vehicle uint64 :offset-assert 208)
|
|
(speech-time uint64 :offset-assert 216)
|
|
(accel vector :inline :offset-assert 224)
|
|
(accel-factor vector :inline :offset-assert 240)
|
|
(front-back-interp float :offset-assert 256)
|
|
(left-right-interp float :offset-assert 260)
|
|
(up-down-interp float :offset-assert 264)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x10c
|
|
:flag-assert #x1e0090010c
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wland-driver (process-focusable)
|
|
((vehicle uint64 :offset-assert 208)
|
|
(accel vector :inline :offset-assert 224)
|
|
(accel-factor vector :inline :offset-assert 240)
|
|
(front-back-interp float :offset-assert 256)
|
|
(left-right-interp float :offset-assert 260)
|
|
(up-down-interp float :offset-assert 264)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x10c
|
|
:flag-assert #x1e0090010c
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern kleever-pilot-trans function)
|
|
;; (define-extern kleever-pilot-wcar-anim-loop function)
|
|
;; (define-extern kleever-rider-init-by-other function)
|
|
;; (define-extern kleever-rider-spawn function)
|
|
;; (define-extern wland-driver-pilot-trans function)
|
|
;; (define-extern wland-driver-pilot-wcar-anim-loop function)
|
|
;; (define-extern wland-driver-init-by-other function)
|
|
;; (define-extern wland-driver-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-hash ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern add-collide-debug-box function) ;; (function vector rgba none)
|
|
;; (define-extern print-collide-cache-tri-count function) ;; (function none)
|
|
;; (define-extern print-exceeded-max-cache-tris function) ;; (function none)
|
|
;; (define-extern fill-bg-using-box-new function) ;; (function collide-cache object collide-query none)
|
|
;; (define-extern fill-bg-using-line-sphere-new function) ;; (function collide-cache object collide-query none)
|
|
;; (define-extern collide-list-fill-bg-using-box function) ;; (function collide-cache collide-list collide-query none)
|
|
;; (define-extern collide-list-fill-bg-using-line-sphere function) ;; (function collide-cache collide-list collide-query none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sync-info-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sync-info-params (structure)
|
|
((sync-type symbol :offset-assert 0) ;; guessed by decompiler
|
|
(sync-flags uint64 :offset-assert 8) ;; sync-flags
|
|
(entity basic :offset-assert 16)
|
|
(period uint32 :offset-assert 20)
|
|
(percent float :offset-assert 24)
|
|
(ease-in float :offset-assert 28)
|
|
(ease-out float :offset-assert 32)
|
|
(pause-in float :offset-assert 36)
|
|
(pause-out float :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sync-info (structure)
|
|
((sync-flags uint64 :offset-assert 0) ;; sync-flags
|
|
(offset float :offset-assert 8)
|
|
(period uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x10
|
|
:flag-assert #x1000000010
|
|
(:methods
|
|
(sync-info-method-9 () none) ;; 9 ;; (get-current-phase-no-mod (_type_) float 9)
|
|
(sync-info-method-10 () none) ;; 10 ;; (get-phase-offset (_type_) float 10)
|
|
(sync-info-method-11 () none) ;; 11 ;; (get-norm! (_type_ int) float 11)
|
|
(sync-info-method-12 () none) ;; 12 ;; (get-scaled-val! (_type_ float int) float 12)
|
|
(sync-info-method-13 () none) ;; 13 ;; (initialize! (_type_ sync-info-params) none 13)
|
|
(sync-info-method-14 () none) ;; 14 ;; (get-timeframe-offset! (_type_ time-frame) time-frame 14)
|
|
(sync-info-method-15 () none) ;; 15 ;; (sync-now! (_type_ float) none 15)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sync-linear (sync-info)
|
|
()
|
|
:method-count-assert 16
|
|
:size-assert #x10
|
|
:flag-assert #x1000000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sync-eased (sync-info)
|
|
((tlo float :offset-assert 16)
|
|
(thi float :offset-assert 20)
|
|
(ylo float :offset-assert 24)
|
|
(m2 float :offset-assert 28)
|
|
(yend float :offset-assert 32)
|
|
(pause-in float :offset-assert 36)
|
|
(pause-out float :offset-assert 40)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x2c
|
|
:flag-assert #x100000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sync-paused (sync-info)
|
|
((pause-in float :offset-assert 16)
|
|
(pause-out float :offset-assert 20)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x18
|
|
:flag-assert #x1000000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype delayed-rand-float (structure)
|
|
((min-time int32 :offset-assert 0)
|
|
(max-time int32 :offset-assert 4)
|
|
(max-val float :offset-assert 8)
|
|
(timer int32 :offset-assert 12)
|
|
(start-time uint64 :offset-assert 16) ;; time-frame
|
|
(value float :offset-assert 24)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x1c
|
|
:flag-assert #xd0000001c
|
|
(:methods
|
|
(delayed-rand-float-method-9 () none) ;; 9 ;; (set-params! (_type_ int int float) float 9)
|
|
(delayed-rand-float-method-10 () none) ;; 10 ;; (reset! (_type_) float 10)
|
|
(delayed-rand-float-method-11 () none) ;; 11 ;; (update! (_type_) float 11)
|
|
(delayed-rand-float-method-12 () none) ;; 12 ;; (update-and-clear! (_type_) none 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype oscillating-float (structure)
|
|
((value float :offset-assert 0)
|
|
(target float :offset-assert 4)
|
|
(vel float :offset-assert 8)
|
|
(max-vel float :offset-assert 12)
|
|
(damping float :offset-assert 16)
|
|
(accel float :offset-assert 20)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x18
|
|
:flag-assert #xb00000018
|
|
(:methods
|
|
(oscillating-float-method-9 () none) ;; 9 ;; (set-params! (_type_ float float float float) float 9)
|
|
(oscillating-float-method-10 () none) ;; 10 ;; (update! (_type_ float) float 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bouncing-float (structure)
|
|
((osc oscillating-float :inline :offset-assert 0)
|
|
(max-value float :offset-assert 24)
|
|
(min-value float :offset-assert 28)
|
|
(elasticity float :offset-assert 32)
|
|
(state int32 :offset-assert 36)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x28
|
|
:flag-assert #xd00000028
|
|
(:methods
|
|
(bouncing-float-method-9 () none) ;; 9 ;; (set-params! (_type_ float float float float float float float) float 9)
|
|
(bouncing-float-method-10 () none) ;; 10 ;; (update! (_type_ float) float 10)
|
|
(bouncing-float-method-11 () none) ;; 11 ;; (at-min? (_type_) symbol 11)
|
|
(bouncing-float-method-12 () none) ;; 12 ;; (at-max? (_type_) symbol 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype delayed-rand-vector (structure)
|
|
((min-time int32 :offset-assert 0)
|
|
(max-time int32 :offset-assert 4)
|
|
(xz-max float :offset-assert 8)
|
|
(y-max float :offset-assert 12)
|
|
(timer int32 :offset-assert 16)
|
|
(start-time uint64 :offset-assert 24) ;; time-frame
|
|
(value vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x30
|
|
:flag-assert #xd00000030
|
|
(:methods
|
|
(delayed-rand-vector-method-9 () none) ;; 9 ;; (set-params! (_type_ int int float float) vector 9)
|
|
(delayed-rand-vector-method-10 () none) ;; 10 ;; (update-now! (_type_) vector 10)
|
|
(delayed-rand-vector-method-11 () none) ;; 11 ;; (update-with-delay! (_type_) vector 11)
|
|
(delayed-rand-vector-method-12 () none) ;; 12 ;; (update-with-delay-or-reset! (_type_) vector 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype oscillating-vector (structure)
|
|
((value vector :inline :offset-assert 0)
|
|
(target vector :inline :offset-assert 16)
|
|
(vel vector :inline :offset-assert 32)
|
|
(max-vel float :offset-assert 48)
|
|
(damping float :offset-assert 52)
|
|
(accel float :offset-assert 56)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x3c
|
|
:flag-assert #xb0000003c
|
|
(:methods
|
|
(oscillating-vector-method-9 () none) ;; 9 ;; (set-params! (_type_ vector float float float) vector 9)
|
|
(oscillating-vector-method-10 () none) ;; 10 ;; (update! (_type_ vector) vector 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcano-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *volcanoa-alpha-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; comb-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype comb-elevator (elevator)
|
|
()
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype comb-pillar (process-focusable)
|
|
((center-pos vector :inline :offset-assert 208)
|
|
(attack-vel vector :inline :offset-assert 224)
|
|
(exploder-params basic :offset-assert 240)
|
|
(exploder-skel basic :offset-assert 244)
|
|
(exploder-anim uint32 :offset-assert 248)
|
|
(hit-points float :offset-assert 252)
|
|
(incoming-attack-id int32 :offset-assert 256)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x104
|
|
:flag-assert #x2400900104
|
|
(:methods
|
|
(comb-pillar-method-30 () none) ;; 30
|
|
(comb-pillar-method-31 () none) ;; 31
|
|
(comb-pillar-method-32 () none) ;; 32
|
|
(comb-pillar-method-33 () none) ;; 33
|
|
(comb-pillar-method-34 () none) ;; 34
|
|
(comb-pillar-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
explode ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype comb-block (process-focusable)
|
|
((attack-vel vector :inline :offset-assert 208)
|
|
(exploder-params basic :offset-assert 224)
|
|
(exploder-skel basic :offset-assert 228)
|
|
(exploder-anim uint32 :offset-assert 232)
|
|
(hit-points float :offset-assert 236)
|
|
(incoming-attack-id int32 :offset-assert 240)
|
|
(parts UNKNOWN 4 :offset-assert 244)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x104
|
|
:flag-assert #x2400900104
|
|
(:methods
|
|
(comb-block-method-30 () none) ;; 30
|
|
(comb-block-method-31 () none) ;; 31
|
|
(comb-block-method-32 () none) ;; 32
|
|
(comb-block-method-33 () none) ;; 33
|
|
(comb-block-method-34 () none) ;; 34
|
|
(comb-block-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
explode ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype comb-energy-ring (process-focusable)
|
|
((speed float :offset-assert 208)
|
|
(hum-id uint32 :offset-assert 212)
|
|
(bolt basic :offset-assert 216)
|
|
(shocked-player basic :offset-assert 220)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #xe0
|
|
:flag-assert #x22006000e0
|
|
(:methods
|
|
(comb-energy-ring-method-29 () none) ;; 29
|
|
(comb-energy-ring-method-30 () none) ;; 30
|
|
(comb-energy-ring-method-31 () none) ;; 31
|
|
(comb-energy-ring-method-32 () none) ;; 32
|
|
(comb-energy-ring-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype comb-turbo (process-drawable)
|
|
((touch-time uint64 :offset-assert 200)
|
|
(player-got basic :offset-assert 208)
|
|
(boost float :offset-assert 212)
|
|
(plane vector :inline :offset-assert 224)
|
|
(mat matrix :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x130
|
|
:flag-assert #x1900b00130
|
|
(:methods
|
|
(comb-turbo-method-22 () none) ;; 22
|
|
(comb-turbo-method-23 () none) ;; 23
|
|
(comb-turbo-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-lightjak-training-shield (task-manager)
|
|
((gui-id uint32 :offset-assert 240)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xf4
|
|
:flag-assert #x21008000f4
|
|
(:methods
|
|
(task-manager-lightjak-training-shield-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *comb-pillar-explode-params* joint-exploder-static-params)
|
|
;; (define-extern *comb-block-explode-params* joint-exploder-static-params)
|
|
;; (define-extern *comb-energy-ring-lightning-width* curve2d-fast)
|
|
;; (define-extern *comb-energy-ring-lightning* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-flyer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mh-flyer-shot (projectile)
|
|
((tail-pos vector :inline :offset-assert 512)
|
|
(hit-pos vector :inline :offset-assert 528)
|
|
(turn-quat quaternion :inline :offset-assert 544)
|
|
(minimap connection-minimap :offset-assert 560)
|
|
(hit-actor? basic :offset-assert 564)
|
|
(last-hit-time uint64 :offset-assert 568)
|
|
(snd-whoosh uint32 :offset-assert 576)
|
|
(muzzle-flash-part basic :offset-assert 580)
|
|
(particle-trail basic :offset-assert 584)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x24c
|
|
:flag-assert #x2901d0024c
|
|
(:state-methods
|
|
impact ;; 22
|
|
dissipate ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-flyer (enemy)
|
|
((rotation-matrix matrix :inline :offset-assert 560)
|
|
(move-curve cubic-curve :inline :offset-assert 624)
|
|
(init-pos vector :inline :offset-assert 688)
|
|
(move-dest vector :inline :offset-assert 704)
|
|
(target-velocity vector :inline :offset-assert 720)
|
|
(focus-bullseye-pos vector :inline :offset-assert 736)
|
|
(focus-xz-dir vector :inline :offset-assert 752)
|
|
(minimap connection-minimap :offset-assert 768)
|
|
(des-path desbeast-path :offset-assert 772)
|
|
(manager uint64 :offset-assert 776)
|
|
(path-pos uint32 :offset-assert 784)
|
|
(bank-angle float :offset-assert 788)
|
|
(pitch-angle float :offset-assert 792)
|
|
(missiles-fired int32 :offset-assert 796)
|
|
(last-fire-time uint64 :offset-assert 800)
|
|
(last-player-screech uint64 :offset-assert 808)
|
|
(jitter float :offset-assert 816)
|
|
)
|
|
:method-count-assert 159
|
|
:size-assert #x334
|
|
:flag-assert #x9f02c00334
|
|
(:methods
|
|
(mh-flyer-method-157 () none) ;; 157
|
|
(mh-flyer-method-158 () none) ;; 158
|
|
)
|
|
(:state-methods
|
|
orbiting ;; 155
|
|
on-path ;; 156
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *mh-flyer-curve-linear-up-red* object)
|
|
;; (define-extern *mh-flyer-trail-color-curve-missile* curve-color-fast)
|
|
;; (define-extern *mh-flyer-curve-missile-linear-trail* curve2d-fast)
|
|
;; (define-extern *mh-flyer-missile-trail* object)
|
|
;; (define-extern mh-flyer-shot-move function)
|
|
;; (define-extern *mh-flyer-shadow-control* shadow-control)
|
|
;; (define-extern *mh-flyer-enemy-info* enemy-info)
|
|
;; (define-extern mh-flyer-fly-post function)
|
|
;; (define-extern get-interp-mod-time function)
|
|
;; (define-extern mh-flyer-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pov-camera-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pov-camera (process-drawable)
|
|
((flags int32 :offset-assert 200) ;; pov-camera-flag
|
|
(debounce-start-time uint64 :offset-assert 208) ;; time-frame
|
|
(notify-handle uint64 :offset-assert 216) ;; handle
|
|
(anim-name string :offset-assert 224) ;; guessed by decompiler
|
|
(command-list pair :offset-assert 228) ;; guessed by decompiler
|
|
(mask-to-clear process-mask :offset-assert 232) ;; guessed by decompiler
|
|
(music-volume-movie float :offset-assert 236)
|
|
(sfx-volume-movie float :offset-assert 240)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #xf4
|
|
:flag-assert #x1e008000f4
|
|
(:methods
|
|
(pov-camera-method-20 () none) ;; 20 ;; (pov-camera-abort () _type_ :state 20)
|
|
(pov-camera-method-21 () none) ;; 21 ;; (pov-camera-done-playing () _type_ :state 21)
|
|
(pov-camera-method-22 () none) ;; 22 ;; (pov-camera-playing () _type_ :state 22)
|
|
(pov-camera-method-23 () none) ;; 23 ;; (pov-camera-start-playing () _type_ :state 23)
|
|
(pov-camera-method-24 () none) ;; 24 ;; (pov-camera-startup () _type_ :state 24)
|
|
(pov-camera-method-25 () none) ;; 25 ;; (abort? (_type_) symbol 25)
|
|
(pov-camera-method-26 () none) ;; 26 ;; (target-grabbed? (_type_) symbol 26)
|
|
(pov-camera-method-27 () none) ;; 27 ;; (pov-camera-method-27 () none 27)
|
|
(pov-camera-method-28 () none) ;; 28 ;; (pov-camera-method-28 () none 28)
|
|
(pov-camera-method-29 () none) ;; 29 ;; (target-released? (_type_) symbol 29)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-blue-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gun-blue-shot-3 (projectile)
|
|
((hit-actor? basic :offset-assert 512)
|
|
(start-pos vector :inline :offset-assert 528)
|
|
(track-mode uint64 :offset-assert 544)
|
|
(random-travel-distance float :offset-assert 552)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x22c
|
|
:flag-assert #x2901b0022c
|
|
(:state-methods
|
|
dissipate ;; 21
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dist-dot-val (structure)
|
|
((dot float :offset-assert 0)
|
|
(dist float :offset-assert 4)
|
|
(current-dir-vec vector :inline :offset-assert 16)
|
|
(vec-to-target vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-tracker-blue-3 (light-trail-tracker-projectile)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xb8
|
|
:flag-assert #x16004000b8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype target-quality-info (structure)
|
|
((targ uint64 :offset-assert 0)
|
|
(value float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype timeframe-wrapper (structure)
|
|
((time uint64 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-blue-2-lightning-info (structure)
|
|
((pts UNKNOWN 32 :offset-assert 0)
|
|
(num-pts int8 :offset-assert 512)
|
|
(should-draw-terminal-sparks? basic :offset-assert 516)
|
|
(terminal-spark-pos vector :inline :offset-assert 528)
|
|
(should-draw-extension? basic :offset-assert 544)
|
|
(extension-end-point vector :inline :offset-assert 560)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x240
|
|
:flag-assert #x900000240
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-blue-lightning-command (structure)
|
|
((msg uint64 :offset-assert 0)
|
|
(lightning-info gun-blue-2-lightning-info :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x250
|
|
:flag-assert #x900000250
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-blue-2-lightning-tracker (process-drawable)
|
|
((lt-array basic :offset-assert 200)
|
|
(should-draw-this-frame? basic :offset-assert 204)
|
|
(last-spark-time uint64 :offset-assert 216)
|
|
(spark-time-interval uint64 :offset-assert 224)
|
|
(last-deduct-ammo-time uint64 :offset-assert 232)
|
|
(snd-lightning uint32 :offset-assert 240)
|
|
(active-enter-time uint64 :offset-assert 248)
|
|
(revolve-angle float :offset-assert 256)
|
|
(sway-angle float :offset-assert 260)
|
|
(snd-spin uint32 :offset-assert 264)
|
|
(spin-intensity float :offset-assert 268)
|
|
(prev-targ-pos vector :inline :offset-assert 272)
|
|
(last-probe-index int16 :offset-assert 288)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #x122
|
|
:flag-assert #x1b00b00122
|
|
(:methods
|
|
(gun-blue-2-lightning-tracker-method-24 () none) ;; 24
|
|
(gun-blue-2-lightning-tracker-method-25 () none) ;; 25
|
|
(gun-blue-2-lightning-tracker-method-26 () none) ;; 26
|
|
)
|
|
(:state-methods
|
|
die ;; 22
|
|
inactive ;; 21
|
|
active ;; 20
|
|
test ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-blue-2-target-info (structure)
|
|
((target uint64 :offset-assert 0)
|
|
(start-time uint64 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype constraint-knot (structure)
|
|
((pt vector :inline :offset-assert 0)
|
|
(dir vector :inline :offset-assert 16)
|
|
(length float :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-constraint (structure)
|
|
((constraints UNKNOWN 12 :offset-assert 0)
|
|
(num-knots uint8 :offset-assert 576)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x241
|
|
:flag-assert #xa00000241
|
|
(:methods
|
|
(rope-constraint-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-blue-2-lightning-init-params (structure)
|
|
((num-beams int8 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1
|
|
:flag-assert #x900000001
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-blue-shot (projectile)
|
|
((init-pos vector :inline :offset-assert 512)
|
|
(init-dir vector :inline :offset-assert 528)
|
|
(collide-normal vector :inline :offset-assert 544)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x230
|
|
:flag-assert #x2901b00230
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-blue-shot-2 (gun-blue-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x230
|
|
:flag-assert #x2901b00230
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sparticle-fade-alpha-dist function)
|
|
;; (define-extern gun-fire-blue-1 function)
|
|
;; (define-extern fmod-2 function)
|
|
;; (define-extern get-dist-and-dot function)
|
|
;; (define-extern gun-blue-shot-3-move function)
|
|
;; (define-extern *blue-shot-trail* object)
|
|
;; (define-extern gun-fire-blue-3 function)
|
|
;; (define-extern draw-beam-segment function)
|
|
;; (define-extern *found-objects* object)
|
|
;; (define-extern *gun-blue-2-last-attack-id* object)
|
|
;; (define-extern *gun-blue-2-last-attack-id-time* object)
|
|
;; (define-extern fire-projectile-if-necessary function)
|
|
;; (define-extern *gun-blue-2-targets* object)
|
|
;; (define-extern *blue-2-lightning-shape* object)
|
|
;; (define-extern *uv-loop-curve* object)
|
|
;; (define-extern *blue-light-test* object)
|
|
;; (define-extern *blue-light-test-end* object)
|
|
;; (define-extern *blue-light-test-big* object)
|
|
;; (define-extern *blue-light-test-big-intense* object)
|
|
;; (define-extern *blue-light-test-small-fade* object)
|
|
;; (define-extern gun-blue-2-lightning-init-by-other function)
|
|
;; (define-extern create-lightning-tracker-if-necessary function)
|
|
;; (define-extern is-valid-blue-2-target function)
|
|
;; (define-extern find-gun-blue-2-target function)
|
|
;; (define-extern find-gun-blue-2-target-old function)
|
|
;; (define-extern *lightning-pts-cache* object)
|
|
;; (define-extern gun-fire-blue-2 function)
|
|
;; (define-extern gun-fire-blue-2-old function)
|
|
;; (define-extern target-gun-can-fire-blue? function)
|
|
;; (define-extern *last-fire-blue-time* object)
|
|
;; (define-extern target-gun-fire-blue function) ;; (function (pointer process) :behavior target)
|
|
;; (define-extern gun-blue-shot-move function) ;; (function gun-blue-shot none)
|
|
;; (define-extern cshape-reaction-blue-shot function) ;; (function control-info collide-query vector vector collide-status)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cloth ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern get-neighboring-faces function)
|
|
;; (define-extern *normal-array* object)
|
|
;; (define-extern light-vertex function)
|
|
;; (define-extern *once* object)
|
|
;; (define-extern *cloth-fade-alpha* object)
|
|
;; (define-extern symbol->cloth-flags function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precurc-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype precur-elevator (elevator)
|
|
()
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-door-a (process-drawable)
|
|
((open-test basic :offset-assert 200)
|
|
(open-started uint64 :offset-assert 208)
|
|
(do-camera? basic :offset-assert 216)
|
|
(open-frame float :offset-assert 220)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xe0
|
|
:flag-assert #x17006000e0
|
|
;; field open-test uses ~A with a signed load.
|
|
(:methods
|
|
(precur-door-a-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
close ;; 21
|
|
open ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-swingpole-pop (swingpole)
|
|
((moving? basic :offset-assert 284)
|
|
(player-grabbed? basic :offset-assert 288)
|
|
(halfway? basic :offset-assert 292)
|
|
(stopped-time uint64 :offset-assert 296)
|
|
(movedist float :offset-assert 304)
|
|
(tt float :offset-assert 308)
|
|
(paused-time uint64 :offset-assert 312)
|
|
(direction uint8 :offset-assert 320)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x141
|
|
:flag-assert #x1900d00141
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; forest-obs-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype shaker (structure)
|
|
((axis vector :inline :offset-assert 0)
|
|
(start-time uint64 :offset-assert 16) ;; time-frame
|
|
(decay-time float :offset-assert 24)
|
|
(amplitude float :offset-assert 28)
|
|
(freq float :offset-assert 32)
|
|
(y-decay-time float :offset-assert 36)
|
|
(y-amplitude float :offset-assert 40)
|
|
(y-freq float :offset-assert 44)
|
|
(shake float :offset-assert 48)
|
|
(y-shake float :offset-assert 52)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x38
|
|
:flag-assert #xa00000038
|
|
(:methods
|
|
(shaker-method-9 () none) ;; 9 ;; (shaker-method-9 (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bombbot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bombbot-hud (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bombbot-bomb (process-focusable)
|
|
((explode-part basic :offset-assert 208)
|
|
(rot-axis vector :inline :offset-assert 224)
|
|
(rot-angle float :offset-assert 240)
|
|
(warning-glow-part basic :offset-assert 244)
|
|
(next-countdown-tick uint64 :offset-assert 248)
|
|
(fizzle-timer uint64 :offset-assert 256)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x108
|
|
:flag-assert #x2200900108
|
|
(:methods
|
|
(bombbot-bomb-method-32 () none) ;; 32
|
|
(bombbot-bomb-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
back ;; 31
|
|
explode ;; 30
|
|
smoke ;; 29
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bombbot-foot (structure)
|
|
((pos-offset vector :inline :offset-assert 0)
|
|
(joint-index uint32 :offset-assert 16)
|
|
(offset float :offset-assert 20)
|
|
(position vector :inline :offset-assert 32)
|
|
(next-position vector :inline :offset-assert 48)
|
|
(real-position vector :inline :offset-assert 64)
|
|
(speed vector :inline :offset-assert 80)
|
|
(moving symbol :offset-assert 96) ;; guessed by decompiler
|
|
(main-y float :offset-assert 100)
|
|
(delta-y float :offset-assert 104)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6c
|
|
:flag-assert #x90000006c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bombbot (nav-enemy)
|
|
((joint-ik joint-mod-ik 4 :offset-assert 620) ;; guessed by decompiler
|
|
(feet bombbot-foot 4 :offset-assert 640) ;; guessed by decompiler
|
|
(legs-strength float 4 :offset-assert 1088) ;; guessed by decompiler
|
|
(last-trans vector :inline :offset-assert 1104)
|
|
(linear-speed vector :inline :offset-assert 1120)
|
|
(last-quat quaternion :inline :offset-assert 1136)
|
|
(y-angular-velocity float :offset-assert 1152)
|
|
(main-quat quaternion :inline :offset-assert 1168)
|
|
(main-spd-y float :offset-assert 1184)
|
|
(main-pos-y float :offset-assert 1188)
|
|
(main-pos vector :inline :offset-assert 1200)
|
|
(city-path bombbot-path :offset-assert 1216)
|
|
(current-node uint32 :offset-assert 1220)
|
|
(shot-count uint32 :offset-assert 1224)
|
|
(next-shoot uint64 :offset-assert 1232)
|
|
(stop-shoot uint64 :offset-assert 1240)
|
|
(next-target uint64 :offset-assert 1248)
|
|
(start-target uint64 :offset-assert 1256)
|
|
(beep-time uint64 :offset-assert 1264) ;; time-frame
|
|
(target-pos vector :inline :offset-assert 1280)
|
|
(start-target-pos vector :inline :offset-assert 1296)
|
|
(start-target-vel vector :inline :offset-assert 1312)
|
|
(target-delta vector :inline :offset-assert 1328)
|
|
(top-quat quaternion :inline :offset-assert 1344)
|
|
(gun-swivel-quat quaternion :inline :offset-assert 1360)
|
|
(gun-quat quaternion :inline :offset-assert 1376)
|
|
(angle-turret float :offset-assert 1392)
|
|
(angle-gun float :offset-assert 1396)
|
|
(extra-angle-gun float :offset-assert 1400)
|
|
(drop-angle float :offset-assert 1404)
|
|
(drop-num uint32 :offset-assert 1408)
|
|
(hit-axis vector :inline :offset-assert 1424)
|
|
(rigidbody rigid-body-control :offset-assert 1440) ;; guessed by decompiler
|
|
(info rigid-body-object-constants :offset-assert 1444)
|
|
(explosing symbol :offset-assert 1448) ;; guessed by decompiler
|
|
(minimap connection-minimap :offset-assert 1452)
|
|
(head-sound sound-id :offset-assert 1456) ;; guessed by decompiler
|
|
(cannon-sound sound-id :offset-assert 1460) ;; guessed by decompiler
|
|
(last-head-roty-speed float :offset-assert 1464)
|
|
(head-roty-speed float :offset-assert 1468)
|
|
(last-cannon-roty-speed float :offset-assert 1472)
|
|
(cannon-roty-speed float :offset-assert 1476)
|
|
(shoot-duration float :offset-assert 1480)
|
|
(y-angle float :offset-assert 1484)
|
|
(gun-rotation-speed float :offset-assert 1488)
|
|
(gun-type uint32 :offset-assert 1492)
|
|
(drop-mask uint32 :offset-assert 1496)
|
|
(attacker-info city-attacker-info :offset-assert 1500)
|
|
(mission-squad basic :offset-assert 1504)
|
|
(max-hit-points float :offset-assert 1508)
|
|
)
|
|
:method-count-assert 209
|
|
:size-assert #x5e8
|
|
:flag-assert #xd1057005e8
|
|
(:methods
|
|
(bombbot-method-192 () none) ;; 192
|
|
(bombbot-method-194 () none) ;; 194
|
|
(bombbot-method-195 () none) ;; 195
|
|
(bombbot-method-196 () none) ;; 196
|
|
(bombbot-method-197 () none) ;; 197
|
|
(bombbot-method-198 () none) ;; 198
|
|
(bombbot-method-199 () none) ;; 199
|
|
(bombbot-method-200 () none) ;; 200
|
|
(bombbot-method-201 () none) ;; 201
|
|
(bombbot-method-202 () none) ;; 202
|
|
(bombbot-method-203 () none) ;; 203
|
|
(bombbot-method-204 () none) ;; 204
|
|
(bombbot-method-205 () none) ;; 205
|
|
(bombbot-method-206 () none) ;; 206
|
|
(bombbot-method-207 () none) ;; 207
|
|
(bombbot-method-208 () none) ;; 208
|
|
)
|
|
(:state-methods
|
|
notice ;; 35
|
|
hostile ;; 38
|
|
explode ;; 190
|
|
drop-bombs ;; 193
|
|
blow-wall ;; 191
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bombbot-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spring-setup (structure)
|
|
((bpos1 vector :offset-assert 0)
|
|
(wpos2 vector :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bombbot-spawn-params (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(nav-mesh basic :offset-assert 32)
|
|
(path bombbot-path :offset-assert 36)
|
|
(first-node uint32 :offset-assert 40)
|
|
(stop-offset float :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bomb-bot (bombbot)
|
|
()
|
|
:method-count-assert 209
|
|
:size-assert #x5e8
|
|
:flag-assert #xd1057005e8
|
|
(:state-methods
|
|
hostile ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bombbot-player (bombbot)
|
|
((camera-x-angle float :offset-assert 1512)
|
|
(hold-fire basic :offset-assert 1516)
|
|
(hold-fire-time uint64 :offset-assert 1520)
|
|
(health-hud uint64 :offset-assert 1528)
|
|
)
|
|
:method-count-assert 210
|
|
:size-assert #x600
|
|
:flag-assert #xd205800600
|
|
(:state-methods
|
|
hostile ;; 38
|
|
explode ;; 190
|
|
done ;; 209
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-blow-barricade (task-manager)
|
|
((check-timer uint64 :offset-assert 236)
|
|
(bombbot-h uint64 :offset-assert 244)
|
|
(actor-group uint32 :offset-assert 252)
|
|
(actor-group-count int32 :offset-assert 256)
|
|
(done? int32 :offset-assert 260)
|
|
(minimap connection-minimap :offset-assert 264)
|
|
(wall-h uint64 :offset-assert 268)
|
|
(start-point vector :inline :offset-assert 284)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x130
|
|
:flag-assert #x2100b00130
|
|
(:methods
|
|
(task-manager-blow-barricade-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-port-fight (task-manager)
|
|
((check-timer uint64 :offset-assert 236)
|
|
(bombbot-h UNKNOWN 4 :offset-assert 244)
|
|
(actor-group uint32 :offset-assert 276)
|
|
(actor-group-count int32 :offset-assert 280)
|
|
(done? int32 :offset-assert 284)
|
|
(minimap connection-minimap :offset-assert 288)
|
|
(min-time uint32 :offset-assert 292)
|
|
(hud-timer uint64 :offset-assert 196)
|
|
(intro-state int32 :offset-assert 308)
|
|
(intro-time uint64 :offset-assert 228)
|
|
(target-far-enough? basic :offset-assert 324)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x14c
|
|
:flag-assert #x2200d0014c
|
|
(:methods
|
|
(task-manager-port-fight-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
fail-screen ;; 32
|
|
wait ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *bombbot-hint* object)
|
|
;; (define-extern *bombbot-hint-time* object)
|
|
;; (define-extern *bombbot-body-constants* object) ;; rigid-body-object-constants
|
|
;; (define-extern bombbot-bomb-handler function)
|
|
;; (define-extern *daxter-speech* object)
|
|
;; (define-extern bombbot-bomb-reaction function)
|
|
;; (define-extern bombbot-bomb-init-by-other function)
|
|
;; (define-extern *bombbot-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern *bombbot-ik-limb-setup* array)
|
|
;; (define-extern bombbot-do-spline function) ;; (function vector vector vector vector vector float vector)
|
|
;; (define-extern spawn-bombbot-projectile function)
|
|
;; (define-extern *bombbot-debris-params* debris-static-params)
|
|
;; (define-extern bombbot-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern bombbot-head-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern bombbot-gun-swivel-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern bombbot-gun-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern *bombbot-spring-setup* array) ;; (array spring-setup)
|
|
;; (define-extern bombbot-init-by-other function) ;; (function bombbot-spawn-params none :behavior bombbot)
|
|
;; (define-extern bombbot-player-init-by-other function)
|
|
;; (define-extern *blow-barricade-kg-squad-member-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; smush-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype smush-control (structure)
|
|
((start-time uint64 :offset-assert 0) ;; time-frame
|
|
(period float :offset-assert 8)
|
|
(duration float :offset-assert 12)
|
|
(amp float :offset-assert 16)
|
|
(damp-amp float :offset-assert 20)
|
|
(damp-period float :offset-assert 24)
|
|
(ticks float :offset-assert 28)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x20
|
|
:flag-assert #xf00000020
|
|
(:methods
|
|
(smush-control-method-9 () none) ;; 9 ;; (set-zero! (_type_) _type_ 9)
|
|
(smush-control-method-10 () none) ;; 10 ;; (update! (_type_) float 10)
|
|
(smush-control-method-11 () none) ;; 11 ;; (get-no-update (_type_) float 11)
|
|
(smush-control-method-12 () none) ;; 12 ;; (activate! (_type_ float int int float float clock) _type_ 12)
|
|
(smush-control-method-13 () none) ;; 13 ;; (nonzero-amplitude? (_type_) symbol 13)
|
|
(smush-control-method-14 () none) ;; 14 ;; (die-on-next-update! (_type_) _type_ 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-update ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern plane-from-points function) ;; (function (inline-array plane) vector vector vector int float)
|
|
;; (define-extern set-point function) ;; (function vector float float float float)
|
|
;; (define-extern update-view-planes function) ;; (function math-camera (inline-array plane) float matrix float)
|
|
;; (define-extern *update-leaf-when-outside-bsp* object) ;; symbol
|
|
;; (define-extern update-visible function) ;; (function math-camera symbol)
|
|
;; (define-extern *save-camera-inv-rot* object) ;; matrix
|
|
;; (define-extern move-camera-from-pad function) ;; (function math-camera math-camera)
|
|
;; (define-extern external-cam-reset! function) ;; (function none)
|
|
;; (define-extern *start-timer* object) ;; int
|
|
;; (define-extern *timer-value* object) ;; int
|
|
;; (define-extern *start-pos* object) ;; vector
|
|
;; (define-extern update-camera function) ;; (function symbol)
|
|
;; (define-extern move-level-by-name function) ;; (function symbol float float float vector)
|
|
;; (define-extern execute-cam-post-hook-engine function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; debug-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pos-history (structure)
|
|
((points (inline-array vector) :offset-assert 0) ;; guessed by decompiler
|
|
(num-points int32 :offset-assert 4)
|
|
(h-first int32 :offset-assert 8)
|
|
(h-last int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-vertex (structure)
|
|
((trans vector4w :inline :offset-assert 0)
|
|
(normal vector3h :inline :offset-assert 16)
|
|
(st vector2h :inline :offset-assert 22)
|
|
(color uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-vertex-stats (basic)
|
|
((length int32 :offset-assert 4)
|
|
(pos-count int32 :offset-assert 8)
|
|
(vertex debug-vertex 600 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4b10
|
|
:flag-assert #x900004b10
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *color-black* object) ;; rgba
|
|
;; (define-extern *color-white* object) ;; rgba
|
|
;; (define-extern *color-gray* object) ;; rgba
|
|
;; (define-extern *color-red* object) ;; rgba
|
|
;; (define-extern *color-green* object) ;; rgba
|
|
;; (define-extern *color-blue* object) ;; rgba
|
|
;; (define-extern *color-cyan* object) ;; rgba
|
|
;; (define-extern *color-magenta* object) ;; rgba
|
|
;; (define-extern *color-yellow* object) ;; rgba
|
|
;; (define-extern *color-light-red* object) ;; rgba
|
|
;; (define-extern *color-light-green* object) ;; rgba
|
|
;; (define-extern *color-light-blue* object) ;; rgba
|
|
;; (define-extern *color-light-cyan* object) ;; rgba
|
|
;; (define-extern *color-light-magenta* object) ;; rgba
|
|
;; (define-extern *color-light-yellow* object) ;; rgba
|
|
;; (define-extern *color-dark-red* object) ;; rgba
|
|
;; (define-extern *color-dark-green* object) ;; rgba
|
|
;; (define-extern *color-dark-blue* object) ;; rgba
|
|
;; (define-extern *color-dark-cyan* object) ;; rgba
|
|
;; (define-extern *color-dark-magenta* object) ;; rgba
|
|
;; (define-extern *color-dark-yellow* object) ;; rgba
|
|
;; (define-extern *color-orange* object) ;; rgba
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; progress-draw ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *progress-list-level* object)
|
|
;; (define-extern sort-task-node-result function) ;; (function int none)
|
|
;; (define-extern find-mission-text-at-index function) ;; (function int game-task-node-info)
|
|
;; (define-extern unlocked-secret-menu? function) ;; (function game-secrets symbol)
|
|
;; (define-extern memcard-unlocked-secrets? function) ;; (function symbol game-secrets)
|
|
;; (define-extern num-unlocked-secret? function) ;; (function game-secrets int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctysluma-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-color-rubble-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-rubble-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-rubble-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-rubble-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-rubble-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-rubble-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-rubble-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-rubble-flame* curve2d-fast)
|
|
;; (define-extern *curve-scale-rubble-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-scale-rubble-flame-y* curve2d-fast)
|
|
;; (define-extern *part-ctyslum-rubble-fire-flame-curve-settings* object)
|
|
;; (define-extern check-drop-level-ctysluma-drop-userdata function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; joint-mod-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype joint-mod (basic)
|
|
((mode joint-mod-mode :offset-assert 4) ;; guessed by decompiler
|
|
(process process-drawable :offset-assert 8) ;; guessed by decompiler
|
|
(joint cspace :offset-assert 12)
|
|
(target vector :inline :offset-assert 16)
|
|
(twist vector :inline :offset-assert 32)
|
|
(twist-max vector :inline :offset-assert 48)
|
|
(extra-twist deg :offset-assert 40) ;; degrees
|
|
(track-mode track-mode :offset-assert 44)
|
|
(look-at-count uint16 :offset-assert 46)
|
|
(twist-range-x meters :offset-assert 56)
|
|
(twist-range-y meters :offset-assert 60)
|
|
(twist-speed-x float :offset-assert 64)
|
|
(twist-speed-y float :offset-assert 68)
|
|
(trans vector :inline :offset-assert 80)
|
|
(smushy-old float :offset-assert 80)
|
|
(smushy-off float :offset-assert 84)
|
|
(smushyv float :offset-assert 88)
|
|
(quat quaternion :inline :offset-assert 96)
|
|
(scale vector :inline :offset-assert 112)
|
|
(notice-time uint64 :offset-assert 128) ;; time-frame
|
|
(flex-blend float :offset-assert 136)
|
|
(blend float :offset-assert 140)
|
|
(old-blend float :offset-assert 144)
|
|
(max-dist meters :offset-assert 148)
|
|
(ignore-angle deg :offset-assert 152) ;; degrees
|
|
(up uint8 :offset-assert 156)
|
|
(nose uint8 :offset-assert 157)
|
|
(ear uint8 :offset-assert 158)
|
|
(base-joint uint8 :offset-assert 159)
|
|
(base-nose uint8 :offset-assert 160)
|
|
(shutting-down? symbol :offset-assert 164) ;; guessed by decompiler
|
|
(parented-scale? symbol :offset-assert 168) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xac
|
|
:flag-assert #x10000000ac
|
|
;; field track-mode is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type joint-mod-mode process-drawable int) _type_ 0)
|
|
(joint-mod-method-9 () none) ;; 9 ;; (mode-set! (_type_ joint-mod-mode) none 9)
|
|
(joint-mod-method-10 () none) ;; 10 ;; (target-set! (_type_ vector) none 10)
|
|
(joint-mod-method-11 () none) ;; 11 ;; (look-at! (_type_ vector symbol process) none 11)
|
|
(joint-mod-method-12 () none) ;; 12 ;; (reset-blend! (_type_) _type_ 12)
|
|
(joint-mod-method-13 () none) ;; 13 ;; (twist-set! (_type_ float float float) vector 13)
|
|
(joint-mod-method-14 () none) ;; 14 ;; (trs-set! (_type_ vector quaternion vector) none 14)
|
|
(joint-mod-method-15 () none) ;; 15 ;; (shut-down (_type_) none 15)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype try-to-look-at-info (basic)
|
|
((who uint64 :offset-assert 8) ;; handle
|
|
(horz float :offset-assert 16)
|
|
(vert float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-spinner (basic)
|
|
((spin-axis vector :inline :offset-assert 16)
|
|
(angle float :offset-assert 32)
|
|
(spin-rate float :offset-assert 36)
|
|
(enable symbol :offset-assert 40) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-base (structure)
|
|
((flags uint16 :offset-assert 0)
|
|
(node-index int16 :offset-assert 2)
|
|
(proc uint32 :offset-assert 4)
|
|
(callback basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #xc
|
|
:flag-assert #xc0000000c
|
|
(:methods
|
|
(joint-mod-base-method-9 () none) ;; 9
|
|
(joint-mod-base-method-10 () none) ;; 10
|
|
(joint-mod-base-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-rotate-local (joint-mod-base)
|
|
((rotation quaternion :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x20
|
|
:flag-assert #xc00000020
|
|
(:methods
|
|
;; (new (symbol type process-drawable int symbol) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-rotate-world (joint-mod-base)
|
|
((rotation quaternion :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x20
|
|
:flag-assert #xc00000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-set-local (joint-mod-base)
|
|
((transform transformq :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x40
|
|
:flag-assert #xc00000040
|
|
(:methods
|
|
;; (new (symbol type process-drawable int symbol symbol symbol) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-add-local (joint-mod-base)
|
|
((transform transformq :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x40
|
|
:flag-assert #xc00000040
|
|
(:methods
|
|
;; (new (symbol type process-drawable int symbol symbol symbol) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-set-world (joint-mod-base)
|
|
((transform transformq :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x40
|
|
:flag-assert #xc00000040
|
|
(:methods
|
|
;; (new (symbol type process-drawable int symbol) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-set-world-no-trans (joint-mod-base)
|
|
((transform transformq :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x40
|
|
:flag-assert #xc00000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-blend-local (joint-mod-base)
|
|
((transform transformq :inline :offset-assert 16)
|
|
(blend-transform transformq :inline :offset-assert 64)
|
|
(blend float :offset-assert 112)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x74
|
|
:flag-assert #xc00000074
|
|
(:methods
|
|
;; (new (symbol type process-drawable int symbol) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-blend-world (joint-mod-base)
|
|
((transform transformq :inline :offset-assert 16)
|
|
(blend-transform transformq :inline :offset-assert 64)
|
|
(blend float :offset-assert 112)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x74
|
|
:flag-assert #xc00000074
|
|
(:methods
|
|
;; (new (symbol type process-drawable int symbol float) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-ik (basic)
|
|
((flags joint-mod-ik-flags :offset-assert 4) ;; guessed by decompiler
|
|
(process process-drawable :offset-assert 8) ;; guessed by decompiler
|
|
(hand-dist float :offset-assert 12)
|
|
(handle-pos vector :inline :offset-assert 16)
|
|
(elbow-pole-vector-axis uint32 :offset-assert 32)
|
|
(elbow-rotation-axis uint32 :offset-assert 36)
|
|
(user-position vector :inline :offset-assert 48)
|
|
(user-normal vector :inline :offset-assert 64)
|
|
(user-blend float :offset-assert 80)
|
|
(user-float float :offset-assert 84)
|
|
(callback (function joint-mod-ik matrix matrix vector object) :offset-assert 88) ;; guessed by decompiler
|
|
(shoulder-matrix-no-ik matrix :inline :offset-assert 96)
|
|
(elbow-matrix-no-ik matrix :inline :offset-assert 160)
|
|
(blend float :offset-assert 224)
|
|
(blend-interp float :offset-assert 228)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #xe8
|
|
:flag-assert #xb000000e8
|
|
(:methods
|
|
;; (new (symbol type process-drawable int float) _type_ 0)
|
|
(joint-mod-ik-method-9 () none) ;; 9 ;; (handle-copy! (_type_ vector) none 9)
|
|
(joint-mod-ik-method-10 () none) ;; 10 ;; (enable-set! (_type_ symbol) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ik-limb-setup (structure)
|
|
((elbow-index int32 :offset-assert 0)
|
|
(hand-dist float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-polar-look-at (basic)
|
|
((flags uint32 :offset-assert 4)
|
|
(ear int8 :offset-assert 8)
|
|
(up int8 :offset-assert 9)
|
|
(nose int8 :offset-assert 10)
|
|
(polar-internal-tilt-max float :offset-assert 12)
|
|
(polar-internal-radius float :offset-assert 16)
|
|
(polar-external-tilt-max float :offset-assert 20)
|
|
(polar-external-radius float :offset-assert 24)
|
|
(upward-tilt float :offset-assert 28)
|
|
(downward-tilt float :offset-assert 32)
|
|
(forward-twist float :offset-assert 36)
|
|
(backward-twist float :offset-assert 40)
|
|
(target vector :inline :offset-assert 48)
|
|
(blend-duration uint64 :offset-assert 64)
|
|
(blend-start-time uint64 :offset-assert 72)
|
|
(blend-start-value float :offset-assert 80)
|
|
(blend-max float :offset-assert 84)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x58
|
|
:flag-assert #xf00000058
|
|
(:methods
|
|
(joint-mod-polar-look-at-method-9 () none) ;; 9
|
|
(joint-mod-polar-look-at-method-10 () none) ;; 10
|
|
(joint-mod-polar-look-at-method-11 () none) ;; 11
|
|
(joint-mod-polar-look-at-method-12 () none) ;; 12
|
|
(joint-mod-polar-look-at-method-13 () none) ;; 13
|
|
(joint-mod-polar-look-at-method-14 () none) ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern joint-mod-debug-draw function) ;; (function joint-mod none)
|
|
;; (define-extern joint-mod-spinner-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern joint-mod-rotate-local-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern vector<-cspace2! function)
|
|
;; (define-extern joint-mod-rotate-world-callback function)
|
|
;; (define-extern joint-mod-set-local-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern joint-mod-add-local-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern joint-mod-set-world-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern joint-mod-set-world-no-trans-callback function)
|
|
;; (define-extern joint-mod-blend-local-callback function) ;; (function cspace transformq none)
|
|
;; (define-extern joint-mod-blend-world-callback function) ;; (function cspace transformq none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-func-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-mesh-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collide-tri-result (structure)
|
|
((vertex vector 3 :offset-assert 0) ;; guessed by decompiler
|
|
(intersect vector :inline :offset-assert 48)
|
|
(normal vector :inline :offset-assert 64)
|
|
(pat pat-surface :offset-assert 80) ;; guessed by decompiler
|
|
(collide-ptr basic :offset-assert 84)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x58
|
|
:flag-assert #x900000058
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-mesh-tri (structure)
|
|
((vertex-index uint8 3 :offset-assert 0) ;; guessed by decompiler
|
|
(unused uint8 :offset-assert 3)
|
|
(pat pat-surface :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-mesh (basic)
|
|
((joint-id int32 :offset-assert 4)
|
|
(num-tris uint32 :offset-assert 8)
|
|
(num-verts uint32 :offset-assert 12)
|
|
(vertex-data (inline-array vector) :offset-assert 16) ;; guessed by decompiler
|
|
(tris collide-mesh-tri 1 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x28
|
|
:flag-assert #x1000000028
|
|
(:methods
|
|
(collide-mesh-method-9 () none) ;; 9 ;; (debug-draw-tris (_type_ process-drawable int) none 9)
|
|
(collide-mesh-method-10 () none) ;; 10 ;; (overlap-test (_type_ collide-mesh-cache-tri vector) symbol 10)
|
|
(collide-mesh-method-11 () none) ;; 11 ;; (should-push-away-test (_type_ collide-mesh-cache-tri collide-tri-result vector float) float 11)
|
|
(collide-mesh-method-12 () none) ;; 12 ;; (sphere-on-platform-test (_type_ collide-mesh-cache-tri collide-tri-result vector float) float 12)
|
|
(collide-mesh-method-13 () none) ;; 13 ;; (unpack-mesh-to-cache! (_type_ (inline-array collide-mesh-cache-tri) matrix) none 13)
|
|
(collide-mesh-method-14 () none) ;; 14 ;; (collide-mesh-math-1 (_type_ object object) none 14)
|
|
(collide-mesh-method-15 () none) ;; 15 ;; (collide-mesh-math-2 (_type_ object object object) none 15)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-mesh-cache-tri (structure)
|
|
((vertex vector 3 :offset-assert 0) ;; guessed by decompiler
|
|
(normal vector :inline :offset-assert 48)
|
|
(bbox4w bounding-box4w :inline :offset-assert 64)
|
|
(pat pat-surface :offset-assert 60) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-mesh-cache-entry (structure)
|
|
((mat matrix :inline :offset-assert 0)
|
|
(tris collide-mesh-cache-tri :dynamic :offset-assert 64) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-mesh-cache (basic)
|
|
((used-size uint32 :offset-assert 4)
|
|
(max-size uint32 :offset-assert 8)
|
|
(id uint32 :offset-assert 12)
|
|
(data uint8 48000 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #xbb90
|
|
:flag-assert #xd0000bb90
|
|
(:methods
|
|
(collide-mesh-cache-method-9 () none) ;; 9 ;; (populate-for-prim-mesh (_type_ collide-shape-prim-mesh) collide-mesh-cache-entry 9)
|
|
(collide-mesh-cache-method-10 () none) ;; 10 ;; (is-id? (_type_ int) symbol 10)
|
|
(collide-mesh-cache-method-11 () none) ;; 11 ;; (next-id! (_type_) uint 11)
|
|
(collide-mesh-cache-method-12 () none) ;; 12 ;; (allocate! (_type_ int) collide-mesh-cache-entry 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *collide-mesh-cache* object) ;; collide-mesh-cache
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; anim-tester ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype list-control (structure)
|
|
((listfunc (function int list-control symbol) :offset-assert 0) ;; guessed by decompiler
|
|
(list-owner uint32 :offset-assert 4)
|
|
(top int32 :offset-assert 8)
|
|
(left int32 :offset-assert 12)
|
|
(list glst-list :offset-assert 16)
|
|
(the-node glst-node :offset-assert 20)
|
|
(top-index int32 :offset-assert 24)
|
|
(the-index int32 :offset-assert 28)
|
|
(the-disp-line int32 :offset-assert 32)
|
|
(highlight-index int32 :offset-assert 36)
|
|
(current-index int32 :offset-assert 40)
|
|
(numlines int32 :offset-assert 44)
|
|
(lines-to-disp int32 :offset-assert 48)
|
|
(charswide int32 :offset-assert 52)
|
|
(highlight-disp-line int32 :offset-assert 56)
|
|
(field-id int32 :offset-assert 60)
|
|
(xpos int32 :offset-assert 64)
|
|
(ypos int32 :offset-assert 68)
|
|
(user-info int32 :offset-assert 72)
|
|
(return-int int32 :offset-assert 76)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype list-field (structure)
|
|
((left int32 :offset-assert 0)
|
|
(width int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype DISP_LIST-bank (basic)
|
|
((V_SPACING int32 :offset-assert 4)
|
|
(BORDER_WIDTH int32 :offset-assert 8)
|
|
(BORDER_HEIGHT int32 :offset-assert 12)
|
|
(MAX_LINES int32 :offset-assert 16)
|
|
(CHAR_WIDTH int32 :offset-assert 20)
|
|
(INC_DELAY int32 :offset-assert 24)
|
|
(BORDER_LINES int32 :offset-assert 28)
|
|
(CXOFF int32 :offset-assert 32)
|
|
(CYOFF int32 :offset-assert 36)
|
|
(BXOFF int32 :offset-assert 40)
|
|
(BYOFF int32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype anim-tester-bank (basic)
|
|
((ANIM_SPEED float :offset-assert 4)
|
|
(BLEND float :offset-assert 8)
|
|
(OBJECT_LIST_X int32 :offset-assert 12)
|
|
(OBJECT_LIST_Y int32 :offset-assert 16)
|
|
(OBJECT_LIST_MIN_WIDTH int32 :offset-assert 20)
|
|
(ANIM_LIST_X int32 :offset-assert 24)
|
|
(ANIM_LIST_Y int32 :offset-assert 28)
|
|
(ANIM_LIST_MIN_WIDTH int32 :offset-assert 32)
|
|
(PICK_LIST_X int32 :offset-assert 36)
|
|
(PICK_LIST_Y int32 :offset-assert 40)
|
|
(PICK_LIST_MIN_WIDTH int32 :offset-assert 44)
|
|
(EDIT_LIST_X int32 :offset-assert 48)
|
|
(EDIT_LIST_Y int32 :offset-assert 52)
|
|
(EDIT_STATS_X int32 :offset-assert 56)
|
|
(EDIT_LIST_MIN_WIDTH int32 :offset-assert 60)
|
|
(EDIT_PICK_X int32 :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
;; anim-tester is already defined!
|
|
|
|
#|
|
|
(deftype anim-test-obj (glst-named-node)
|
|
((obj-art-group basic :offset-assert 12)
|
|
(seq-list glst-list :inline :offset-assert 16)
|
|
(flags int32 :offset-assert 32)
|
|
(mesh-geo basic :offset-assert 36)
|
|
(joint-geo basic :offset-assert 40)
|
|
(list-con list-control :inline :offset-assert 44)
|
|
(parent uint32 :offset-assert 124)
|
|
(anim-index int32 :offset-assert 128)
|
|
(anim-hindex int32 :offset-assert 132)
|
|
(seq-index int32 :offset-assert 136)
|
|
(seq-hindex int32 :offset-assert 140)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype anim-test-sequence (glst-named-node)
|
|
((item-list glst-list :inline :offset-assert 12)
|
|
(playing-item int32 :offset-assert 28)
|
|
(flags int32 :offset-assert 32)
|
|
(list-con list-control :inline :offset-assert 36)
|
|
(parent anim-test-obj :offset-assert 116)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x78
|
|
:flag-assert #x900000078
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype anim-test-seq-item (glst-named-node)
|
|
((speed int32 :offset-assert 12)
|
|
(blend int32 :offset-assert 16)
|
|
(first-frame float :offset-assert 20)
|
|
(last-frame float :offset-assert 24)
|
|
(num-frames float :offset-assert 28)
|
|
(artist-base float :offset-assert 32)
|
|
(flags int32 :offset-assert 36)
|
|
(parent anim-test-sequence :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *DISP_LIST-bank* DISP_LIST-bank)
|
|
;; (define-extern display-list-control function)
|
|
;; (define-extern *ANIM_TESTER-bank* anim-tester-bank)
|
|
;; (define-extern anim-tester-num-print function)
|
|
;; (define-extern *anim-tester* object) ;; (pointer anim-tester)
|
|
;; (define-extern anim-test-obj-init function)
|
|
;; (define-extern anim-test-sequence-init function)
|
|
;; (define-extern anim-test-seq-item-copy! function)
|
|
;; (define-extern anim-test-obj-item-valid? function)
|
|
;; (define-extern anim-test-obj-remove-invalid function)
|
|
;; (define-extern anim-tester-real-post function)
|
|
;; (define-extern anim-tester-post function)
|
|
;; (define-extern anim-tester-update-anim-info function)
|
|
;; (define-extern anim-tester-reset function)
|
|
;; (define-extern anim-tester-disp-frame-num function)
|
|
;; (define-extern anim-tester-standard-event-handler function)
|
|
;; (define-extern anim-test-obj-list-handler function)
|
|
;; (define-extern anim-test-anim-list-handler function)
|
|
;; (define-extern anim-test-sequence-list-handler function)
|
|
;; (define-extern anim-test-field-highlight-lw object)
|
|
;; (define-extern anim-tester-adjust-frame function)
|
|
;; (define-extern anim-tester-pick-item-setup function)
|
|
;; (define-extern anim-test-seq-mark-as-edited function)
|
|
;; (define-extern anim-test-edit-seq-insert-item function)
|
|
;; (define-extern anim-test-edit-sequence-list-handler function)
|
|
;; (define-extern anim-tester-interface function)
|
|
;; (define-extern anim-tester-get-playing-item function)
|
|
;; (define-extern initialize-anim-tester function)
|
|
;; (define-extern anim-tester-string-get-frame!! function)
|
|
;; (define-extern anim-tester-load-object-seqs function)
|
|
;; (define-extern anim-tester-save-object-seqs function)
|
|
;; (define-extern anim-tester-save-all-objects function)
|
|
;; (define-extern anim-tester-add-newobj function)
|
|
;; (define-extern anim-tester-stop function)
|
|
;; (define-extern anim-tester-start function) ;; (function symbol)
|
|
;; (define-extern anim-tester-add-object function) ;; (function string none)
|
|
;; (define-extern anim-tester-set-name function)
|
|
;; (define-extern anim-tester-add-sequence function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctywide-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern birth-func-ctywide-baron-propoganda-ticker-rotate function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern *range-color-gas-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-gas-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-gas-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-gas-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-gas-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-gas-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-gas-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-gas-flame* curve2d-fast)
|
|
;; (define-extern *curve-gas-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-gas-flame-y* curve2d-fast)
|
|
;; (define-extern *part-ctyind-hot-gas-curve-settings* object)
|
|
;; (define-extern *range-kgpickup-dust-color* curve-color-fast)
|
|
;; (define-extern *range-kgpickup-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-kgpickup-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-kgpickup-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-kgpickup-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-kgpickup-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-kgpickup-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-hijack-kgpickup-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-kgpickup-color* curve-color-fast)
|
|
;; (define-extern *range-kgpickup-alpha* curve2d-fast)
|
|
;; (define-extern *range-kgpickup-scale-x* curve2d-fast)
|
|
;; (define-extern *range-kgpickup-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-kgpickup-alpha* curve2d-fast)
|
|
;; (define-extern *curve-kgpickup-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-kgpickup-scale-y* curve2d-fast)
|
|
;; (define-extern *part-hijack-kgpickup-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tfrag-near ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern tnear-vu1-block object) ;; vu-function
|
|
;; (define-extern tfrag-details function) ;; (function tfragment none)
|
|
;; (define-extern clip-restore function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-shape-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collide-rider (structure)
|
|
((rider-handle uint64 :offset-assert 0) ;; handle
|
|
(sticky-prim collide-shape-prim :offset-assert 8) ;; guessed by decompiler
|
|
(prim-ry float :offset-assert 12)
|
|
(rider-local-pos vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-rider-pool (basic)
|
|
((alloc-count int32 :offset-assert 4)
|
|
(riders collide-rider 20 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x290
|
|
:flag-assert #xb00000290
|
|
(:methods
|
|
(collide-rider-pool-method-9 () none) ;; 9 ;; (add-rider (_type_ handle) collide-rider 9)
|
|
(collide-rider-pool-method-10 () none) ;; 10 ;; (prepare (_type_) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pull-rider-info (structure)
|
|
((rider collide-rider :offset-assert 0)
|
|
(rider-cshape collide-shape-moving :offset-assert 4) ;; guessed by decompiler
|
|
(rider-delta-ry float :offset-assert 8)
|
|
(rider-dest vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype overlaps-others-params (structure)
|
|
((options overlaps-others-options :offset-assert 0) ;; guessed by decompiler
|
|
(collide-with-filter collide-spec :offset-assert 4) ;; guessed by decompiler
|
|
(tlist touching-list :offset-assert 8) ;; guessed by decompiler
|
|
(filtered-root-collide-with collide-spec :offset-assert 12) ;; guessed by decompiler
|
|
(filtered-child-collide-with collide-spec :offset-assert 16) ;; guessed by decompiler
|
|
(filtered-other-collide-as collide-spec :offset-assert 20) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype move-above-ground-params (structure)
|
|
((gnd-collide-with collide-spec :offset-assert 0) ;; guessed by decompiler
|
|
(popup float :offset-assert 4)
|
|
(dont-move-if-overlaps? symbol :offset-assert 8) ;; guessed by decompiler
|
|
(hover-if-no-ground? symbol :offset-assert 12) ;; guessed by decompiler
|
|
(overlaps-params overlaps-others-params :inline :offset-assert 16)
|
|
(new-pos vector :inline :offset-assert 48)
|
|
(old-gspot-pos vector :inline :offset-assert 64)
|
|
(old-gspot-normal vector :inline :offset-assert 80)
|
|
(pat pat-surface :offset-assert 96) ;; guessed by decompiler
|
|
(on-ground? symbol :offset-assert 100) ;; guessed by decompiler
|
|
(do-move? symbol :offset-assert 104) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6c
|
|
:flag-assert #x90000006c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-prim-core (structure)
|
|
((world-sphere vector :inline :offset-assert 0)
|
|
(collide-as collide-spec :offset-assert 16) ;; guessed by decompiler
|
|
(collide-with collide-spec :offset-assert 20) ;; guessed by decompiler
|
|
(action collide-action :offset-assert 24) ;; guessed by decompiler
|
|
(prim-type int8 :offset-assert 28) ;; prim-type
|
|
(unused1 uint8 3 :offset-assert 29) ;; guessed by decompiler
|
|
(quad uint128 2 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-shape-prim (basic)
|
|
((cshape collide-shape :offset-assert 4) ;; guessed by decompiler
|
|
(prim-id uint32 :offset-assert 8)
|
|
(transform-index int8 :offset-assert 12)
|
|
(unused2 int8 3 :offset-assert 13) ;; guessed by decompiler
|
|
(prim-core collide-prim-core :inline :offset-assert 16)
|
|
(local-sphere vector :inline :offset-assert 48)
|
|
(specific uint8 16 :offset-assert 64) ;; guessed by decompiler
|
|
(world-sphere vector :inline :offset-assert 16)
|
|
(collide-as collide-spec :offset-assert 32)
|
|
(collide-with collide-spec :offset-assert 36)
|
|
(action collide-action :offset-assert 40)
|
|
(prim-type int8 :offset-assert 44)
|
|
(radius meters :offset-assert 60) ;; float
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x50
|
|
:flag-assert #x1400000050
|
|
(:methods
|
|
;; (new (symbol type collide-shape uint int) _type_ 0)
|
|
(collide-shape-prim-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(collide-shape-prim-method-10 () none) ;; 10 ;; (add-fg-prim-using-box (_type_ collide-cache) none 10)
|
|
(collide-shape-prim-method-11 () none) ;; 11 ;; (add-fg-prim-using-line-sphere (_type_ collide-cache object) none 11)
|
|
(collide-shape-prim-method-12 () none) ;; 12 ;; (overlaps-others-test (_type_ overlaps-others-params collide-shape-prim) symbol 12)
|
|
(collide-shape-prim-method-13 () none) ;; 13 ;; (overlaps-others-group (_type_ overlaps-others-params collide-shape-prim-group) symbol 13)
|
|
(collide-shape-prim-method-14 () none) ;; 14 ;; (collide-shape-prim-method-14 () none 14)
|
|
(collide-shape-prim-method-15 () none) ;; 15 ;; (collide-with-collide-cache-prim-mesh (_type_ collide-query collide-cache-prim) none 15)
|
|
(collide-shape-prim-method-16 () none) ;; 16 ;; (collide-with-collide-cache-prim-sphere (_type_ collide-query collide-cache-prim) none 16)
|
|
(collide-shape-prim-method-17 () none) ;; 17 ;; (on-platform-test (_type_ collide-shape-prim collide-query float) none 17)
|
|
(collide-shape-prim-method-18 () none) ;; 18 ;; (should-push-away-test (_type_ collide-shape-prim collide-query) none 18)
|
|
(collide-shape-prim-method-19 () none) ;; 19 ;; (should-push-away-a-group-test (_type_ collide-shape-prim-group collide-query) none 19)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-shape-prim-sphere (collide-shape-prim)
|
|
((cshape collide-shape :offset-assert 0) ;; guessed by decompiler
|
|
(prim-id uint32 :offset-assert 4)
|
|
(transform-index int8 :offset-assert 8)
|
|
(unused2 int8 3 :offset-assert 9) ;; guessed by decompiler
|
|
(prim-core collide-prim-core :inline :offset-assert 12)
|
|
(local-sphere vector :inline :offset-assert 44)
|
|
(specific uint8 16 :offset-assert 60) ;; guessed by decompiler
|
|
(world-sphere vector :inline :offset-assert 12)
|
|
(collide-as collide-spec :offset-assert 28)
|
|
(collide-with collide-spec :offset-assert 32)
|
|
(action collide-action :offset-assert 36)
|
|
(prim-type int8 :offset-assert 40)
|
|
(radius meters :offset-assert 56) ;; float
|
|
(pat pat-surface :offset-assert 60) ;; guessed by decompiler
|
|
(nav-radius float :offset-assert 64)
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x50
|
|
:flag-assert #x1400000050
|
|
(:methods
|
|
;; (new (symbol type collide-shape uint) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-shape-prim-mesh (collide-shape-prim)
|
|
((cshape collide-shape :offset-assert 0) ;; guessed by decompiler
|
|
(prim-id uint32 :offset-assert 4)
|
|
(transform-index int8 :offset-assert 8)
|
|
(unused2 int8 3 :offset-assert 9) ;; guessed by decompiler
|
|
(prim-core collide-prim-core :inline :offset-assert 12)
|
|
(local-sphere vector :inline :offset-assert 44)
|
|
(specific uint8 16 :offset-assert 60) ;; guessed by decompiler
|
|
(world-sphere vector :inline :offset-assert 12)
|
|
(collide-as collide-spec :offset-assert 28)
|
|
(collide-with collide-spec :offset-assert 32)
|
|
(action collide-action :offset-assert 36)
|
|
(prim-type int8 :offset-assert 40)
|
|
(radius meters :offset-assert 56) ;; float
|
|
(mesh collide-mesh :offset-assert 60) ;; guessed by decompiler
|
|
(mesh-id int32 :offset-assert 64)
|
|
(mesh-cache-id uint32 :offset-assert 68)
|
|
(mesh-cache-entry collide-mesh-cache-entry :offset-assert 72)
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x50
|
|
:flag-assert #x1400000050
|
|
(:methods
|
|
;; (new (symbol type collide-shape uint uint) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-shape-prim-group (collide-shape-prim)
|
|
((cshape collide-shape :offset-assert 0) ;; guessed by decompiler
|
|
(prim-id uint32 :offset-assert 4)
|
|
(transform-index int8 :offset-assert 8)
|
|
(unused2 int8 3 :offset-assert 9) ;; guessed by decompiler
|
|
(prim-core collide-prim-core :inline :offset-assert 12)
|
|
(local-sphere vector :inline :offset-assert 44)
|
|
(specific uint8 16 :offset-assert 60) ;; guessed by decompiler
|
|
(world-sphere vector :inline :offset-assert 12)
|
|
(collide-as collide-spec :offset-assert 28)
|
|
(collide-with collide-spec :offset-assert 32)
|
|
(action collide-action :offset-assert 36)
|
|
(prim-type int8 :offset-assert 40)
|
|
(radius meters :offset-assert 56) ;; float
|
|
(num-children uint8 :offset-assert 60)
|
|
(num-alloc-children uint8 :offset-assert 61)
|
|
(child (inline-array collide-shape-prim) :offset-assert 64) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x50
|
|
:flag-assert #x1400000050
|
|
(:methods
|
|
;; (new (symbol type collide-shape uint int) _type_ 0)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-shape (trsqv)
|
|
((actor-hash-index int16 :offset-assert 12)
|
|
(process process-drawable :offset-assert 140) ;; guessed by decompiler
|
|
(max-iteration-count uint8 :offset-assert 144)
|
|
(nav-flags uint8 :offset-assert 145) ;; nav-flags
|
|
(total-prims uint8 :offset-assert 146)
|
|
(num-riders uint8 :offset-assert 147)
|
|
(event-self symbol :offset-assert 152) ;; guessed by decompiler
|
|
(event-other symbol :offset-assert 156) ;; guessed by decompiler
|
|
(root-prim collide-shape-prim :offset-assert 160) ;; guessed by decompiler
|
|
(riders (inline-array collide-rider) :offset-assert 164) ;; guessed by decompiler
|
|
(penetrate-using penetrate :offset-assert 168)
|
|
(penetrated-by penetrate :offset-assert 176)
|
|
(event-priority uint8 :offset-assert 192)
|
|
(rider-max-momentum float :offset-assert 196)
|
|
)
|
|
:method-count-assert 55
|
|
:size-assert #xc8
|
|
:flag-assert #x37000000c8
|
|
;; field penetrate is likely a value type. field penetrate is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type process-drawable collide-list-enum) _type_ 0)
|
|
(collide-shape-method-28 () none) ;; 28 ;; (move-by-vector! (_type_ vector) none 28)
|
|
(collide-shape-method-29 () none) ;; 29 ;; (move-to-point! (_type_ vector) none 29)
|
|
(collide-shape-method-30 () none) ;; 30 ;; (debug-draw (_type_) none 30)
|
|
(collide-shape-method-31 () none) ;; 31 ;; (fill-cache-for-shape (_type_ float collide-query) none 31)
|
|
(collide-shape-method-32 () none) ;; 32 ;; (fill-cache-integrate-and-collide (_type_ vector collide-query meters) none 32)
|
|
(collide-shape-method-33 () none) ;; 33 ;; (find-prim-by-id (_type_ uint) collide-shape-prim 33)
|
|
(collide-shape-method-34 () none) ;; 34 ;; (find-prim-by-id-logtest (_type_ uint) collide-shape-prim 34)
|
|
(collide-shape-method-35 () none) ;; 35 ;; (detect-riders! (_type_) symbol 35)
|
|
(collide-shape-method-36 () none) ;; 36 ;; (build-bounding-box-for-shape (_type_ bounding-box float collide-spec) symbol 36)
|
|
(collide-shape-method-37 () none) ;; 37 ;; (integrate-and-collide! (_type_ vector) none 37)
|
|
(collide-shape-method-38 () none) ;; 38 ;; (find-collision-meshes (_type_) none 38)
|
|
(collide-shape-method-39 () none) ;; 39 ;; (on-platform (_type_ collide-shape collide-query) symbol 39)
|
|
(collide-shape-method-40 () none) ;; 40 ;; (find-overlapping-shapes (_type_ overlaps-others-params) symbol 40)
|
|
(collide-shape-method-41 () none) ;; 41 ;; (shove-to-closest-point-on-path (_type_ attack-info float) vector 41)
|
|
(collide-shape-method-42 () none) ;; 42 ;; (should-push-away (_type_ collide-shape collide-query) symbol 42)
|
|
(collide-shape-method-43 () none) ;; 43 ;; (pull-rider! (_type_ pull-rider-info) none 43)
|
|
(collide-shape-method-44 () none) ;; 44 ;; (pull-riders! (_type_) symbol 44)
|
|
(collide-shape-method-45 () none) ;; 45 ;; (do-push-aways (_type_) collide-spec 45)
|
|
(collide-shape-method-46 () none) ;; 46 ;; (update-transforms (_type_) none 46)
|
|
(collide-shape-method-47 () none) ;; 47 ;; (set-collide-with! (_type_ collide-spec) none 47)
|
|
(collide-shape-method-48 () none) ;; 48 ;; (set-collide-as! (_type_ collide-spec) none 48)
|
|
(collide-shape-method-49 () none) ;; 49 ;; (modify-collide-as! (_type_ int collide-spec collide-spec) none 49)
|
|
(collide-shape-method-50 () none) ;; 50 ;; (send-shoves (_type_ process touching-shapes-entry float float float) symbol 50)
|
|
(collide-shape-method-51 () none) ;; 51 ;; (above-ground? (_type_ collide-query vector collide-spec float float float) symbol 51)
|
|
(collide-shape-method-52 () none) ;; 52 ;; (water-info-init! (_type_ water-info collide-action) water-info 52)
|
|
(collide-shape-method-53 () none) ;; 53 ;; (iterate-prims (_type_ (function collide-shape-prim none)) none 53)
|
|
(collide-shape-method-54 () none) ;; 54 ;; (pusher-init (_type_) none 54)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-shape-moving (collide-shape)
|
|
((rider-time uint64 :offset-assert 200) ;; time-frame
|
|
(rider-last-move vector :inline :offset-assert 208)
|
|
(trans-old vector :inline :offset-assert 224)
|
|
(poly-pat pat-surface :offset-assert 272) ;; guessed by decompiler
|
|
(cur-pat pat-surface :offset-assert 276) ;; guessed by decompiler
|
|
(ground-pat pat-surface :offset-assert 280) ;; guessed by decompiler
|
|
(status uint64 :offset-assert 288) ;; collide-status
|
|
(reaction (function control-info collide-query vector vector collide-status) :offset-assert 316) ;; guessed by decompiler
|
|
(no-reaction (function collide-shape-moving collide-query vector vector object) :offset-assert 320) ;; guessed by decompiler
|
|
(local-normal vector :inline :offset-assert 336)
|
|
(surface-normal vector :inline :offset-assert 352)
|
|
(poly-normal vector :inline :offset-assert 368)
|
|
(ground-poly-normal vector :inline :offset-assert 384)
|
|
(gspot-pos vector :inline :offset-assert 400)
|
|
(gspot-normal vector :inline :offset-assert 416)
|
|
(ground-touch-point vector :inline :offset-assert 432)
|
|
(ground-impact-vel meters :offset-assert 448)
|
|
(surface-angle float :offset-assert 452)
|
|
(poly-angle float :offset-assert 456)
|
|
(touch-angle float :offset-assert 460)
|
|
(coverage float :offset-assert 464)
|
|
(dynam dynamics :offset-assert 468) ;; guessed by decompiler
|
|
(surf surface :offset-assert 472) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 68
|
|
:size-assert #x1dc
|
|
:flag-assert #x44000001dc
|
|
;; field penetrate is likely a value type. field penetrate is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type process-drawable collide-list-enum) _type_ 0)
|
|
(collide-shape-moving-method-55 () none) ;; 55 ;; (find-ground (_type_ collide-query collide-spec float float float) symbol 55)
|
|
(collide-shape-moving-method-56 () none) ;; 56 ;; (react-to-pat! (_type_ pat-surface) cshape-reaction-flags 56)
|
|
(collide-shape-moving-method-57 () none) ;; 57 ;; (integrate-no-collide! (_type_ vector) none 57)
|
|
(collide-shape-moving-method-58 () none) ;; 58 ;; (integrate-for-enemy-no-mtg (_type_ vector overlaps-others-params) symbol 58)
|
|
(collide-shape-moving-method-59 () none) ;; 59 ;; (move-above-ground (_type_ vector move-above-ground-params) none 59)
|
|
(collide-shape-moving-method-60 () none) ;; 60 ;; (move-to-ground (_type_ float float symbol collide-spec) none 60)
|
|
(collide-shape-moving-method-61 () none) ;; 61 ;; (move-to-ground-point (_type_ vector vector vector) none 61)
|
|
(collide-shape-moving-method-62 () none) ;; 62 ;; (compute-acc-due-to-gravity (_type_ vector float) vector 62)
|
|
(collide-shape-moving-method-63 () none) ;; 63 ;; (collide-shape-moving-method-63 (_type_ rigid-body float) none 63)
|
|
(collide-shape-moving-method-64 () none) ;; 64 ;; (try-snap-to-surface (_type_ vector float float float) symbol 64)
|
|
(collide-shape-moving-method-65 () none) ;; 65 ;; (fill-and-try-snap-to-surface (_type_ vector float float float collide-query) symbol 65)
|
|
(collide-shape-moving-method-66 () none) ;; 66 ;; (step-collison! (_type_ vector vector float int) float 66)
|
|
(collide-shape-moving-method-67 () none) ;; 67 ;; (collide-with-all-collide-cache-prims (_type_ matrix collide-query) none 67)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *collide-hit-by-player-list* object) ;; engine
|
|
;; (define-extern *collide-hit-by-others-list* object) ;; engine
|
|
;; (define-extern *collide-player-list* object) ;; engine
|
|
;; (define-extern *collide-shape-prim-backgnd* collide-shape-prim-mesh) ;; collide-shape-prim-mesh
|
|
;; (define-extern *collide-shape-prim-water* collide-shape-prim-mesh) ;; collide-shape-prim-mesh
|
|
;; (define-extern *collide-rider-pool* object) ;; collide-rider-pool
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-precura ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *precura-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-obs-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype manipy (process-drawable)
|
|
;; ()
|
|
;; :flag-assert #x1501000174
|
|
;; )
|
|
|
|
#|
|
|
(deftype part-spawner (process)
|
|
((root trsqv :offset-assert 128) ;; guessed by decompiler
|
|
(part sparticle-launch-control :offset-assert 132) ;; guessed by decompiler
|
|
(path basic :offset-assert 136)
|
|
(sound ambient-sound :offset-assert 140) ;; guessed by decompiler
|
|
(sound-extra basic :offset-assert 144)
|
|
(mode (pointer sparticle-launch-group) :offset-assert 148) ;; guessed by decompiler
|
|
(enable symbol :offset-assert 152) ;; guessed by decompiler
|
|
(path-pos float :offset-assert 156)
|
|
(path-speed float :offset-assert 160)
|
|
(last-velocity vector :inline :offset-assert 176)
|
|
(radius meters :offset-assert 192)
|
|
(world-sphere sphere :inline :offset-assert 208)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xe0
|
|
:flag-assert #x10006000e0
|
|
(:methods
|
|
(part-spawner-method-14 () none) ;; 14 ;; (active () _type_ :state 14)
|
|
(part-spawner-method-15 () none) ;; 15 ;; (is-in-view? (_type_) symbol 15)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype part-tracker (process)
|
|
((root trsqv :offset-assert 128) ;; guessed by decompiler
|
|
(mat matrix :inline :offset-assert 144)
|
|
(offset vector :inline :offset-assert 208)
|
|
(userdata uint64 :offset-assert 224)
|
|
(user-time time-frame 2 :offset-assert 232) ;; guessed by decompiler
|
|
(user-vector vector :inline :offset-assert 256)
|
|
(user-handle uint32 2 :offset-assert 288) ;; guessed by decompiler
|
|
(part sparticle-launch-control :offset-assert 296) ;; guessed by decompiler
|
|
(callback (function part-tracker vector) :offset-assert 300) ;; guessed by decompiler
|
|
(linger-callback (function part-tracker vector) :offset-assert 304) ;; guessed by decompiler
|
|
(duration uint64 :offset-assert 312)
|
|
(linger-duration uint64 :offset-assert 320)
|
|
(state-time uint64 :offset-assert 328)
|
|
(target uint64 :offset-assert 336) ;; handle
|
|
(target-joint int32 :offset-assert 344)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x15c
|
|
:flag-assert #x1200e0015c
|
|
;; field userdata uses ~A with a 64-bit load.
|
|
(:methods
|
|
(part-tracker-method-14 () none) ;; 14 ;; (active () _type_ :state 14)
|
|
(part-tracker-method-15 () none) ;; 15 ;; (notify-parent-of-death (_type_) none 15)
|
|
(part-tracker-method-16 () none) ;; 16
|
|
(part-tracker-method-17 () none) ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype part-tracker-init-params (structure)
|
|
((userdata uint64 :offset-assert 0)
|
|
(duration uint64 :offset-assert 8)
|
|
(group basic :offset-assert 16)
|
|
(callback basic :offset-assert 20)
|
|
(target basic :offset-assert 24)
|
|
(mat-joint basic :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
;; field userdata uses ~A with a 64-bit load. field mat-joint uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype part-tracker-subsampler-init-params (structure)
|
|
((userdata uint64 :offset-assert 0)
|
|
(duration uint64 :offset-assert 8)
|
|
(group basic :offset-assert 16)
|
|
(callback basic :offset-assert 20)
|
|
(target basic :offset-assert 24)
|
|
(mat-joint basic :offset-assert 28)
|
|
(subsample-num float :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
;; field userdata uses ~A with a 64-bit load. field mat-joint uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype part-tracker-subsampler (part-tracker)
|
|
((subsampler basic :offset-assert 348)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x160
|
|
:flag-assert #x1200e00160
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-tracker (process)
|
|
((root trsqv :offset-assert 128) ;; guessed by decompiler
|
|
(lightning lightning-control :offset-assert 132) ;; guessed by decompiler
|
|
(callback (function lightning-tracker none) :offset-assert 136) ;; guessed by decompiler
|
|
(duration uint64 :offset-assert 144)
|
|
(start-time uint64 :offset-assert 152) ;; time-frame
|
|
(offset0 vector :inline :offset-assert 160)
|
|
(offset1 vector :inline :offset-assert 176)
|
|
(target0 uint64 :offset-assert 192) ;; handle
|
|
(target1 uint64 :offset-assert 200) ;; handle
|
|
(target-joint0 int32 :offset-assert 208)
|
|
(target-joint1 int32 :offset-assert 212)
|
|
(sound sound-id :offset-assert 216) ;; guessed by decompiler
|
|
(userdata uint64 :offset-assert 224)
|
|
(user-time time-frame 2 :offset-assert 232) ;; guessed by decompiler
|
|
(user-vector vector :inline :offset-assert 256)
|
|
(user-handle handle 2 :offset-assert 288) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x130
|
|
:flag-assert #x1100b00130
|
|
;; field userdata uses ~A with a 64-bit load.
|
|
(:methods
|
|
(lightning-tracker-method-14 () none) ;; 14 ;; (active () _type_ :state 14)
|
|
(lightning-tracker-method-15 () none) ;; 15 ;; (notify-parent-of-death (_type_) none 15)
|
|
(lightning-tracker-method-16 () none) ;; 16 ;; (update (_type_) none 16)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype touch-tracker (process-drawable)
|
|
((duration uint64 :offset-assert 200) ;; time-frame
|
|
(target uint64 :offset-assert 208) ;; handle
|
|
(event symbol :offset-assert 216) ;; guessed by decompiler
|
|
(run-function (function object) :offset-assert 220) ;; guessed by decompiler
|
|
(callback (function touch-tracker none) :offset-assert 224) ;; guessed by decompiler
|
|
(event-mode basic :offset-assert 228)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xe8
|
|
:flag-assert #x15007000e8
|
|
(:methods
|
|
(touch-tracker-method-20 () none) ;; 20 ;; (active () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype swingpole (process-drawable)
|
|
((edge-length meters :offset-assert 200)
|
|
(path-pos float :offset-assert 204)
|
|
(joint-track int32 :offset-assert 208)
|
|
(speed meters :offset-assert 212)
|
|
(dir vector :inline :offset-assert 224)
|
|
(sync sync-eased :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x11c
|
|
:flag-assert #x1900a0011c
|
|
(:methods
|
|
(swingpole-method-20 () none) ;; 20 ;; (idle () _type_ :state 20)
|
|
(swingpole-method-21 () none) ;; 21 ;; (active (handle) _type_ :state 21)
|
|
(swingpole-method-22 () none) ;; 22 ;; (move-along-path (_type_) none 22)
|
|
(swingpole-method-23 () none) ;; 23
|
|
(swingpole-method-24 () none) ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gui-query (structure)
|
|
((x-position int32 :offset-assert 0)
|
|
(y-position int32 :offset-assert 4)
|
|
(message string :offset-assert 8) ;; guessed by decompiler
|
|
(decision symbol :offset-assert 12) ;; guessed by decompiler
|
|
(only-allow-cancel symbol :offset-assert 16) ;; guessed by decompiler
|
|
(no-msg string :offset-assert 20) ;; guessed by decompiler
|
|
(message-space int32 :offset-assert 24)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x1c
|
|
:flag-assert #xb0000001c
|
|
(:methods
|
|
(gui-query-method-9 () none) ;; 9 ;; (gui-query-method-9 () none 9)
|
|
(gui-query-method-10 () none) ;; 10 ;; (gui-query-method-10 () none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype othercam (process)
|
|
((hand uint64 :offset-assert 128) ;; handle
|
|
(old-global-mask process-mask :offset-assert 136) ;; guessed by decompiler
|
|
(mask-to-clear process-mask :offset-assert 140) ;; guessed by decompiler
|
|
(cam-joint-index int32 :offset-assert 144)
|
|
(old-pos vector :inline :offset-assert 160)
|
|
(old-mat-z vector :inline :offset-assert 176)
|
|
(had-valid-frame basic :offset-assert 192)
|
|
(border-value basic :offset-assert 196)
|
|
(die? symbol :offset-assert 200) ;; guessed by decompiler
|
|
(survive-anim-end? symbol :offset-assert 204) ;; guessed by decompiler
|
|
(spooling? symbol :offset-assert 208) ;; guessed by decompiler
|
|
(fov float :offset-assert 212)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #xd8
|
|
:flag-assert #xe006000d8
|
|
(:states
|
|
othercam-running ;; associated process guessed by decompiler, old: (state othercam)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype explosion-init-params (structure)
|
|
((spawn-point vector :inline :offset-assert 0)
|
|
(spawn-quat quaternion :inline :offset-assert 16)
|
|
(radius float :offset-assert 32)
|
|
(scale float :offset-assert 36)
|
|
(group sparticle-launch-group :offset-assert 40) ;; guessed by decompiler
|
|
(collide-with collide-spec :offset-assert 44) ;; guessed by decompiler
|
|
(damage float :offset-assert 48)
|
|
(damage-scale float :offset-assert 52)
|
|
(vehicle-damage-factor float :offset-assert 56)
|
|
(vehicle-impulse-factor float :offset-assert 60)
|
|
(ignore-proc uint64 :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype explosion (process-drawable)
|
|
((start-time uint64 :offset-assert 200) ;; time-frame
|
|
(duration uint32 :offset-assert 208)
|
|
(linger-duration uint32 :offset-assert 212)
|
|
(attack-id uint32 :offset-assert 216)
|
|
(mat matrix :inline :offset-assert 224)
|
|
(params explosion-init-params :inline :offset-assert 288)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x168
|
|
:flag-assert #x1700f00168
|
|
(:methods
|
|
(explosion-method-20 () none) ;; 20 ;; (explode () _type_ :state 20)
|
|
(explosion-method-21 () none) ;; 21 ;; (setup-explosion-collision (_type_) none 21)
|
|
(explosion-method-22 () none) ;; 22 ;; (explosion-method-22 (_type_) none 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype process-hidden (process)
|
|
((name string :offset-assert 0) ;; guessed by decompiler
|
|
(mask process-mask :offset-assert 4)
|
|
(clock clock :offset-assert 8) ;; guessed by decompiler
|
|
(parent (pointer process-tree) :offset-assert 12) ;; guessed by decompiler
|
|
(brother (pointer process-tree) :offset-assert 16) ;; guessed by decompiler
|
|
(child (pointer process-tree) :offset-assert 20) ;; guessed by decompiler
|
|
(ppointer (pointer process) :offset-assert 24) ;; guessed by decompiler
|
|
(self process :offset-assert 28) ;; guessed by decompiler
|
|
(pool dead-pool :offset-assert 32) ;; guessed by decompiler
|
|
(status symbol :offset-assert 36) ;; guessed by decompiler
|
|
(pid int32 :offset-assert 40)
|
|
(main-thread cpu-thread :offset-assert 44) ;; guessed by decompiler
|
|
(top-thread cpu-thread :offset-assert 48) ;; guessed by decompiler
|
|
(entity entity-actor :offset-assert 52) ;; guessed by decompiler
|
|
(level level :offset-assert 56) ;; guessed by decompiler
|
|
(state state :offset-assert 60) ;; guessed by decompiler
|
|
(prev-state basic :offset-assert 64)
|
|
(next-state state :offset-assert 68) ;; guessed by decompiler
|
|
(state-stack basic :offset-assert 72)
|
|
(trans-hook function :offset-assert 76) ;; guessed by decompiler
|
|
(post-hook function :offset-assert 80) ;; guessed by decompiler
|
|
(event-hook (function process int symbol event-message-block object) :offset-assert 84) ;; guessed by decompiler
|
|
(allocated-length int32 :offset-assert 88)
|
|
(heap-base pointer :offset-assert 92) ;; guessed by decompiler
|
|
(heap-top pointer :offset-assert 96) ;; guessed by decompiler
|
|
(heap-cur pointer :offset-assert 100) ;; guessed by decompiler
|
|
(stack-frame-top stack-frame :offset-assert 104) ;; guessed by decompiler
|
|
(heap kheap :inline :offset-assert 92)
|
|
(connection-list connectable :inline :offset-assert 108)
|
|
(stack uint8 :dynamic :offset-assert 124) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
(:methods
|
|
(process-hidden-method-14 () none) ;; 14 ;; (die () _type_ :state 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype simple-prim (process-drawable)
|
|
((strip basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xcc
|
|
:flag-assert #x1a005000cc
|
|
(:methods
|
|
(simple-prim-method-20 () none) ;; 20
|
|
(simple-prim-method-21 () none) ;; 21
|
|
(simple-prim-method-22 () none) ;; 22
|
|
(simple-prim-method-23 () none) ;; 23
|
|
(simple-prim-method-24 () none) ;; 24
|
|
(simple-prim-method-25 () none) ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-arrow-params (structure)
|
|
((flags task-arrow-flags :offset-assert 0) ;; guessed by decompiler
|
|
(map-icon uint16 :offset-assert 4)
|
|
(pos vector :inline :offset-assert 16)
|
|
(quat quaternion :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype external-camera-controller (process)
|
|
((pause-time uint64 :offset-assert 128)
|
|
(blur basic :offset-assert 136)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x8c
|
|
:flag-assert #xf0010008c
|
|
(:methods
|
|
(external-camera-controller-method-14 () none) ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *simple-prim-additive* object)
|
|
;; (define-extern *simple-prim-alpha-blend* object)
|
|
;; (define-extern *simple-prim-subtractive* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; subdivide ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *merc-global-stats* object) ;; merc-global-stats
|
|
;; (define-extern clear-tr-stat function) ;; (function tr-stat none)
|
|
;; (define-extern *stat-string-tfrag* object) ;; string
|
|
;; (define-extern *stat-string-tfrag-scissor* object) ;; string
|
|
;; (define-extern *stat-string-total* object) ;; string
|
|
;; (define-extern print-tr-stat function) ;; (function tr-stat string string none)
|
|
;; (define-extern print-terrain-stats function) ;; (function none)
|
|
;; (define-extern update-subdivide-settings! function) ;; (function subdivide-settings math-camera int none)
|
|
;; (define-extern *subdivide-settings* object) ;; subdivide-settings
|
|
;; (define-extern set-tfrag-dists! function) ;; (function tfrag-dists none)
|
|
;; (define-extern *terrain-context* object) ;; terrain-context
|
|
;; (define-extern GSH_ENABLE object) ;; symbol
|
|
;; (define-extern GSH_BUCKET object) ;; bucket-id
|
|
;; (define-extern GSH_WHICH_STAT object) ;; int
|
|
;; (define-extern GSH_MAX_DISPLAY object) ;; basic
|
|
;; (define-extern GSH_TIME object) ;; int
|
|
;; (define-extern *perf-stats* object) ;; perf-stat-array
|
|
;; (define-extern *gomi-stats-hack* object) ;; (inline-array perf-stat)
|
|
;; (define-extern start-perf-stat-collection function) ;; (function none)
|
|
;; (define-extern end-perf-stat-collection function) ;; (function none)
|
|
;; (define-extern print-perf-stats function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sparticle ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern sp-particle-copy! function) ;; (function sparticle-cpuinfo sparticle-cpuinfo none)
|
|
;; (define-extern *sp-particle-system-2d* object) ;; sparticle-system
|
|
;; (define-extern *sp-particle-system-3d* object) ;; sparticle-system
|
|
;; (define-extern sp-get-block-size function) ;; (function sparticle-system int int)
|
|
;; (define-extern sp-get-approx-alloc-size function) ;; (function sparticle-system int int)
|
|
;; (define-extern sp-free-particle function) ;; (function sparticle-system int sparticle-cpuinfo sprite-vec-data-2d none)
|
|
;; (define-extern sp-get-particle function) ;; (function sparticle-system int sparticle-launch-state sparticle-cpuinfo)
|
|
;; (define-extern sp-kill-particle function) ;; (function sparticle-system sparticle-cpuinfo symbol)
|
|
;; (define-extern sp-orbiter function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sp-process-block-2d function) ;; (function sparticle-system int int int int symbol none)
|
|
;; (define-extern sp-process-block-3d function) ;; (function sparticle-system int int int int symbol none)
|
|
;; (define-extern sp-copy-to-spr function) ;; (function int pointer int none)
|
|
;; (define-extern sp-copy-from-spr function) ;; (function int pointer int none)
|
|
;; (define-extern memcpy function) ;; function
|
|
;; (define-extern sp-process-block function) ;; (function sparticle-system int sprite-array-2d int none)
|
|
;; (define-extern sp-process-particle-system function) ;; (function sparticle-system int sprite-array-2d none)
|
|
;; (define-extern *particles-flag* object) ;; symbol
|
|
;; (define-extern forall-particles-with-key-runner function) ;; (function sparticle-launch-control (function sparticle-system sparticle-cpuinfo none) sparticle-system none)
|
|
;; (define-extern forall-particles-with-key function) ;; (function sparticle-launch-control (function sparticle-system sparticle-cpuinfo none) symbol symbol none)
|
|
;; (define-extern sparticle-kill-it function) ;; (function sparticle-system sparticle-cpuinfo none)
|
|
;; (define-extern *sparticle-kill-it-level* object)
|
|
;; (define-extern sparticle-kill-it-level function)
|
|
;; (define-extern sparticle-60-to-50 function) ;; (function sparticle-system sparticle-cpuinfo pointer none)
|
|
;; (define-extern sparticle-50-to-60 function) ;; (function sparticle-system sparticle-cpuinfo pointer none)
|
|
;; (define-extern kill-all-particles-with-key function) ;; (function sparticle-launch-control none)
|
|
;; (define-extern forall-particles-runner function) ;; (function (function sparticle-system sparticle-cpuinfo pointer none) sparticle-system none)
|
|
;; (define-extern forall-particles function) ;; (function function symbol symbol none)
|
|
;; (define-extern kill-all-particles-in-level function) ;; (function level int)
|
|
;; (define-extern all-particles-50-to-60 function) ;; (function none)
|
|
;; (define-extern all-particles-60-to-50 function) ;; (function none)
|
|
;; (define-extern remap-particle function) ;; (function sparticle-system sparticle-cpuinfo pointer none)
|
|
;; (define-extern remap-all-particles function) ;; (function none)
|
|
;; (define-extern process-particles function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-target-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype control-info (collide-shape-moving)
|
|
;; ()
|
|
;; :flag-assert #x4400001914
|
|
;; )
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; process-drawable-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cspace-by-name-no-fail function) ;; (function process-drawable string cspace)
|
|
;; (define-extern cspace-index-by-name-no-fail function) ;; (function process-drawable string int)
|
|
;; (define-extern num-func-none function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func-+! function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func--! function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func-loop! function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func-loop-speedless! function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func-loop-set! function)
|
|
;; (define-extern num-func-seek! function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func-blend-in! function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern joint-channel-float-delete! function) ;; (function joint-control-channel none)
|
|
;; (define-extern num-func-interp-play! function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func-interp1-play! function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func-chan function) ;; (function joint-control-channel float float float float :behavior process)
|
|
;; (define-extern num-func-identity function) ;; (function joint-control-channel float float float float :behavior process)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; forest-bridges ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype for-break-bridge-board (process-drawable)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
(:methods
|
|
(for-break-bridge-board-method-22 () none) ;; 22
|
|
(for-break-bridge-board-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-break-bridge-board-a (for-break-bridge-board)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-break-bridge-board-b (for-break-bridge-board)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-break-bridge-board-c (for-break-bridge-board)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-break-bridge-board-d (for-break-bridge-board)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *for-break-bridge-board-exploder-params* joint-exploder-static-params)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; process-focusable ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype process-focusable (process-drawable)
|
|
((focus-status uint64 :offset-assert 200) ;; focus-status
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #xd0
|
|
:flag-assert #x1c005000d0
|
|
(:methods
|
|
(process-focusable-method-20 () none) ;; 20 ;; (get-trans (_type_ int) vector 20)
|
|
(process-focusable-method-21 () none) ;; 21 ;; (get-quat (_type_ int) quaternion 21)
|
|
(process-focusable-method-22 () none) ;; 22 ;; (get-transv (_type_) vector 22)
|
|
(process-focusable-method-23 () none) ;; 23 ;; (time-to-apex-or-ground (_type_ int) int 23)
|
|
(process-focusable-method-24 () none) ;; 24 ;; (get-water-height (_type_) meters 24)
|
|
(process-focusable-method-25 () none) ;; 25 ;; (get-notice-time (_type_) time-frame 25)
|
|
(process-focusable-method-26 () none) ;; 26 ;; (get-inv-mass (_type_) float 26)
|
|
(process-focusable-method-27 () none) ;; 27
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; process-taskable-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype process-taskable (process-focusable)
|
|
((flags uint32 :offset-assert 208)
|
|
(task game-task-control :offset-assert 212) ;; guessed by decompiler
|
|
(ambient ambient-control :inline :offset-assert 216)
|
|
(neck-joint-index int32 :offset-assert 232)
|
|
(talk-message text-id :offset-assert 236) ;; guessed by decompiler
|
|
(talk-distance meters :offset-assert 240)
|
|
(talk-height meters :offset-assert 244)
|
|
(last-talk uint64 :offset-assert 248) ;; time-frame
|
|
(want-to-say uint64 :offset-assert 256) ;; time-frame
|
|
(birth-time uint64 :offset-assert 264) ;; time-frame
|
|
(slave uint64 :offset-assert 272) ;; handle
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
(:methods
|
|
(process-taskable-method-28 () none) ;; 28 ;; (idle () _type_ :state 28)
|
|
(process-taskable-method-29 () none) ;; 29 ;; (active (game-task-event) _type_ :state 29)
|
|
(process-taskable-method-30 () none) ;; 30 ;; (play-game (game-task-event) _type_ :state 30)
|
|
(process-taskable-method-31 () none) ;; 31 ;; (process-taskable-method-31 (_type_) none 31)
|
|
(process-taskable-method-32 () none) ;; 32 ;; (process-taskable-method-32 (_type_) none 32)
|
|
(process-taskable-method-33 () none) ;; 33 ;; (init-art! (_type_) none 33)
|
|
(process-taskable-method-34 () none) ;; 34 ;; (process-taskable-method-34 (_type_) symbol 34)
|
|
(process-taskable-method-35 () none) ;; 35 ;; (get-art-elem (_type_) art-element 35)
|
|
(process-taskable-method-36 () none) ;; 36 ;; (process-taskable-method-36 (_type_) none 36)
|
|
(process-taskable-method-37 () none) ;; 37 ;; (process-taskable-method-37 (_type_) none 37)
|
|
(process-taskable-method-38 () none) ;; 38
|
|
(process-taskable-method-39 () none) ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-frag-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collide-frag-vertex (vector)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-frag-mesh (basic)
|
|
((packed-data uint32 :offset-assert 4)
|
|
(pat-array uint32 :offset-assert 8)
|
|
(strip-data-len uint16 :offset-assert 12)
|
|
(poly-count uint16 :offset-assert 14)
|
|
(base-trans vector4w :inline :offset-assert 16)
|
|
(vertex-count uint8 :offset-assert 28)
|
|
(vertex-data-qwc uint8 :offset-assert 29)
|
|
(total-qwc uint8 :offset-assert 30)
|
|
(unused uint8 :offset-assert 31)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-fragment (drawable)
|
|
((mesh collide-frag-mesh :offset-assert 8) ;; guessed by decompiler
|
|
(collide-new basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype drawable-inline-array-collide-fragment (drawable-inline-array)
|
|
((data collide-fragment 1 :offset-assert 36) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x44
|
|
:flag-assert #x1100000044
|
|
)
|
|
|#
|
|
|
|
;; (deftype drawable-tree-collide-fragment (drawable-tree)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; time-of-day ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern time-of-day-effect object) ;; (function none)
|
|
;; (define-extern time-of-day-update function) ;; (function none :behavior time-of-day-proc)
|
|
;; (define-extern update-counters function) ;; (function float :behavior time-of-day-proc)
|
|
;; (define-extern time-of-day-tick state) ;; (state time-of-day-proc)
|
|
;; (define-extern init-time-of-day function) ;; (function object :behavior time-of-day-proc)
|
|
;; (define-extern start-time-of-day function) ;; (function (pointer process))
|
|
;; (define-extern time-of-day-setup function) ;; (function symbol symbol)
|
|
;; (define-extern time-of-day-interp-colors function) ;; (function (pointer rgba) uint mood-context none)
|
|
;; (define-extern time-of-day-interp-colors-scratch function) ;; (function (pointer rgba) time-of-day-palette mood-context none)
|
|
;; (define-extern init-time-of-day-context function) ;; (function time-of-day-context symbol)
|
|
;; (define-extern set-filter-color! function) ;; (function float float float none)
|
|
;; (define-extern tod-madd! function) ;; (function vector vector vector float)
|
|
;; (define-extern update-environment-colors function) ;; (function time-of-day-context vector)
|
|
;; (define-extern update-time-of-day function) ;; (function time-of-day-context none)
|
|
;; (define-extern calc-fade-from-fog function) ;; (function vector float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; effect-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype effect-control (basic)
|
|
((process process-drawable :offset-assert 4) ;; guessed by decompiler
|
|
(flags effect-control-flag :offset-assert 8) ;; guessed by decompiler
|
|
(last-frame-group art-joint-anim :offset-assert 12) ;; guessed by decompiler
|
|
(last-frame-num float :offset-assert 16)
|
|
(channel-offset int32 :offset-assert 20)
|
|
(res res-lump :offset-assert 24) ;; guessed by decompiler
|
|
(name (pointer res-tag) :offset-assert 28) ;; guessed by decompiler
|
|
(param uint32 :offset-assert 32)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x24
|
|
:flag-assert #xf00000024
|
|
(:methods
|
|
;; (new (symbol type process-drawable) _type_ 0)
|
|
(effect-control-method-9 () none) ;; 9 ;; (update-effects (_type_) none 9)
|
|
(effect-control-method-10 () none) ;; 10 ;; (do-effect (_type_ symbol float int) none 10)
|
|
(effect-control-method-11 () none) ;; 11 ;; (do-effect-for-surface (_type_ symbol float int basic pat-surface) none 11)
|
|
(effect-control-method-12 () none) ;; 12 ;; (play-effect-sound (_type_ symbol float int basic sound-name) int 12)
|
|
(effect-control-method-13 () none) ;; 13 ;; (set-channel-offset! (_type_ int) none 13)
|
|
(effect-control-method-14 () none) ;; 14 ;; (play-effects-from-res-lump (_type_ float float float) none 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ff-squad-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *alert-level-settings* object) ;; (inline-array traffic-alert-state-settings)
|
|
;; (define-extern *ff-war-alert-state-settings* object)
|
|
;; (define-extern *ff-guard-type-mask* object)
|
|
;; (define-extern set-ff-primary-target function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; water-info-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype water-info (structure)
|
|
((trans vector :inline :offset-assert 0)
|
|
(normal vector :inline :offset-assert 16)
|
|
(base-height meters :offset-assert 32)
|
|
(depth meters :offset-assert 36)
|
|
(handle uint64 :offset-assert 40) ;; handle
|
|
(flags water-flag :offset-assert 48) ;; water-flags
|
|
(prim drawable-region-prim :offset-assert 52) ;; guessed by decompiler
|
|
(extra-flags uint32 :offset-assert 56)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-sphere (structure)
|
|
((sphere sphere :inline :offset-assert 0)
|
|
(flags water-flag :offset-assert 16)
|
|
(user0 int32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-near ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern ocean-near-block object) ;; vu-function
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; load-dgo ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype load-dgo-msg (structure)
|
|
((rsvd uint16 :offset-assert 0)
|
|
(result uint16 :offset-assert 2) ;; load-msg-result
|
|
(b1 pointer :offset-assert 4) ;; guessed by decompiler
|
|
(b2 pointer :offset-assert 8) ;; guessed by decompiler
|
|
(bt pointer :offset-assert 12) ;; guessed by decompiler
|
|
(name uint128 :offset-assert 16)
|
|
(address uint32 :offset-assert 4)
|
|
(id uint128 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype load-chunk-msg (structure)
|
|
((rsvd uint16 :offset-assert 0)
|
|
(result uint16 :offset-assert 2) ;; load-msg-result
|
|
(address pointer :offset-assert 4) ;; guessed by decompiler
|
|
(section uint32 :offset-assert 8)
|
|
(maxlen uint32 :offset-assert 12)
|
|
(dummy uint32 4 :offset-assert 16) ;; guessed by decompiler
|
|
(basename sound-stream-name :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype play-chunk-msg (structure)
|
|
((rsvd uint16 :offset-assert 0)
|
|
(result uint16 :offset-assert 2)
|
|
(address pointer :offset-assert 4) ;; guessed by decompiler
|
|
(section uint32 :offset-assert 8)
|
|
(volume int32 :offset-assert 8)
|
|
(maxlen uint32 :offset-assert 12)
|
|
(group uint8 :offset-assert 12)
|
|
(id uint32 4 :offset-assert 16) ;; guessed by decompiler
|
|
(basename sound-stream-name 4 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xe0
|
|
:flag-assert #x9000000e0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *load-dgo-rpc* object) ;; rpc-buffer-pair
|
|
;; (define-extern *load-str-rpc* object) ;; rpc-buffer-pair
|
|
;; (define-extern *play-str-rpc* object) ;; rpc-buffer-pair
|
|
;; (define-extern *load-str-lock* object) ;; symbol
|
|
;; (define-extern *que-str-lock* object) ;; symbol
|
|
;; (define-extern *dgo-name* object) ;; string
|
|
;; (define-extern str-load function) ;; (function string int pointer int symbol)
|
|
;; (define-extern str-load-status function) ;; (function (pointer int32) symbol)
|
|
;; (define-extern str-load-cancel function) ;; (function none)
|
|
;; (define-extern str-play-async function) ;; (function string sound-id none)
|
|
;; (define-extern str-play-stop function) ;; (function string sound-id none)
|
|
;; (define-extern str-play-queue function) ;; (function string string string string (pointer uint32) pointer none)
|
|
;; (define-extern str-ambient-play function) ;; (function string none)
|
|
;; (define-extern str-ambient-stop function) ;; (function string none)
|
|
;; (define-extern str-play-kick function) ;; (function none)
|
|
;; (define-extern *dgo-time* object) ;; time-frame
|
|
;; (define-extern dgo-load-begin function) ;; (function string pointer pointer pointer load-dgo-msg)
|
|
;; (define-extern dgo-load-get-next function) ;; (function (pointer symbol) pointer)
|
|
;; (define-extern dgo-load-continue function) ;; (function pointer pointer pointer load-dgo-msg)
|
|
;; (define-extern dgo-load-cancel function) ;; (function none)
|
|
;; (define-extern find-temp-buffer function) ;; (function int pointer)
|
|
;; (define-extern dgo-load-link function) ;; (function dgo-header kheap uint symbol symbol symbol)
|
|
;; (define-extern destroy-mem function) ;; (function (pointer uint32) (pointer uint32) none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable-inline-array ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; chain-physics-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype chain-physics-setup (structure)
|
|
((joint-index int32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype chain-physics-joint (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(velocity vector :inline :offset-assert 16)
|
|
(old-x vector :inline :offset-assert 32)
|
|
(joint-mod joint-mod :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype chain-physics (basic)
|
|
((chain-joints chain-physics-joint 20 :offset-assert 16) ;; guessed by decompiler
|
|
(num-joints uint8 :offset-assert 1296)
|
|
(root-joint-index uint8 :offset-assert 1297)
|
|
(joint-length float :offset-assert 1300)
|
|
(gravity vector :inline :offset-assert 1312)
|
|
(gravity-target vector :inline :offset-assert 1328)
|
|
(stretch-vel float :offset-assert 1344)
|
|
(stretch-vel-parallel float :offset-assert 1348)
|
|
(compress-vel float :offset-assert 1352)
|
|
(compress-vel-parallel float :offset-assert 1356)
|
|
(negate-y symbol :offset-assert 1360) ;; guessed by decompiler
|
|
(axial-slop float :offset-assert 1364)
|
|
(maximum-stretch float :offset-assert 1368)
|
|
(turn-off-start uint64 :offset-assert 1376) ;; time-frame
|
|
(turn-off-duration uint64 :offset-assert 1384) ;; time-frame
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x570
|
|
:flag-assert #x1200000570
|
|
(:methods
|
|
(chain-physics-method-9 () none) ;; 9 ;; (initialize-chain-joints (_type_) symbol 9)
|
|
(chain-physics-method-10 () none) ;; 10 ;; (turn-off (_type_ time-frame) none 10)
|
|
(chain-physics-method-11 () none) ;; 11 ;; (update (_type_ process-drawable) none 11)
|
|
(chain-physics-method-12 () none) ;; 12 ;; (gravity-update (_type_ process-drawable) none 12)
|
|
(chain-physics-method-13 () none) ;; 13 ;; (apply-gravity (_type_ vector int process-drawable) none 13)
|
|
(chain-physics-method-14 () none) ;; 14 ;; (chain-physics-method-14 (_type_ vector int) none 14)
|
|
(chain-physics-method-15 () none) ;; 15 ;; (clamp-length (_type_ vector vector object process-drawable) vector 15)
|
|
(chain-physics-method-16 () none) ;; 16 ;; (chain-physics-method-16 (_type_ int) float 16)
|
|
(chain-physics-method-17 () none) ;; 17 ;; (chain-physics-method-17 (_type_ vector int) none 17)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ragdoll-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ragdoll-edit-info (structure)
|
|
((editing basic :offset-assert 0)
|
|
(current-func uint64 :offset-assert 8)
|
|
(analog-func uint64 :offset-assert 16)
|
|
(affect uint64 :offset-assert 24)
|
|
(single-step uint64 :offset-assert 32)
|
|
(collision basic :offset-assert 40)
|
|
(gravity basic :offset-assert 44)
|
|
(skel-visible uint64 :offset-assert 48)
|
|
(current-joint int8 :offset-assert 56)
|
|
(auto-setup-now basic :offset-assert 60)
|
|
(child-stack UNKNOWN 60 :offset-assert 64)
|
|
(child-stack-num int8 :offset-assert 304)
|
|
(last-frame uint64 :offset-assert 312)
|
|
(last-frame-dur uint64 :offset-assert 320)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x148
|
|
:flag-assert #x1200000148
|
|
(:methods
|
|
(ragdoll-edit-info-method-9 () none) ;; 9
|
|
(ragdoll-edit-info-method-10 () none) ;; 10
|
|
(ragdoll-edit-info-method-11 () none) ;; 11
|
|
(ragdoll-edit-info-method-12 () none) ;; 12
|
|
(ragdoll-edit-info-method-13 () none) ;; 13
|
|
(ragdoll-edit-info-method-14 () none) ;; 14
|
|
(ragdoll-edit-info-method-15 () none) ;; 15
|
|
(ragdoll-edit-info-method-16 () none) ;; 16
|
|
(ragdoll-edit-info-method-17 () none) ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ragdoll-joint-setup (structure)
|
|
((joint-index int32 :offset-assert 0)
|
|
(parent-joint int32 :offset-assert 4)
|
|
(joint-type uint64 :offset-assert 8)
|
|
(pre-tform vector :inline :offset-assert 16)
|
|
(geo-tform vector :inline :offset-assert 32)
|
|
(axial-slop float :offset-assert 48)
|
|
(max-angle float :offset-assert 52)
|
|
(coll-rad float :offset-assert 56)
|
|
(hit-sound uint128 :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ragdoll-setup (structure)
|
|
((orient-tform vector :inline :offset-assert 0)
|
|
(scale vector :inline :offset-assert 16)
|
|
(bg-collide-with uint32 :offset-assert 32)
|
|
(joint-setup basic :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ragdoll-joint (structure)
|
|
((quat quaternion :inline :offset-assert 0)
|
|
(position vector :inline :offset-assert 16)
|
|
(velocity vector :inline :offset-assert 32)
|
|
(bounce vector :inline :offset-assert 48)
|
|
(old-x vector :inline :offset-assert 64)
|
|
(pre-tform vector :inline :offset-assert 80)
|
|
(geo-tform vector :inline :offset-assert 96)
|
|
(axial-slop float :offset-assert 112)
|
|
(max-angle float :offset-assert 116)
|
|
(joint-length float :offset-assert 120)
|
|
(coll-rad float :offset-assert 124)
|
|
(ragdoll-joint-flags uint32 :offset-assert 128)
|
|
(joint-type uint64 :offset-assert 136)
|
|
(joint-index int8 :offset-assert 144)
|
|
(parent-joint int8 :offset-assert 145)
|
|
(parent-index int8 :offset-assert 146)
|
|
(num-children int8 :offset-assert 147)
|
|
(old-param0 basic :offset-assert 148)
|
|
(hit-sound uint128 :offset-assert 160)
|
|
(ground-pat uint32 :offset-assert 176)
|
|
(user0 int32 :offset-assert 180)
|
|
(original-speed float :offset-assert 184)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xbc
|
|
:flag-assert #x9000000bc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ragdoll (basic)
|
|
((ragdoll-joints UNKNOWN 60 :offset-assert 16)
|
|
(num-joints uint8 :offset-assert 11536)
|
|
(mirror matrix :inline :offset-assert 11552)
|
|
(gravity vector :inline :offset-assert 11616)
|
|
(gravity-target vector :inline :offset-assert 11632)
|
|
(orient-tform vector :inline :offset-assert 11648)
|
|
(scale vector :inline :offset-assert 11664)
|
|
(stretch-vel float :offset-assert 11680)
|
|
(stretch-vel-parallel float :offset-assert 11684)
|
|
(compress-vel float :offset-assert 11688)
|
|
(compress-vel-parallel float :offset-assert 11692)
|
|
(momentum float :offset-assert 11696)
|
|
(maximum-stretch float :offset-assert 11700)
|
|
(turn-off-start uint64 :offset-assert 11704)
|
|
(turn-off-duration uint64 :offset-assert 11712)
|
|
(copy-velocity-start uint64 :offset-assert 11720)
|
|
(root-offset vector :inline :offset-assert 11728)
|
|
(rotate-vel quaternion :inline :offset-assert 11744)
|
|
(rotate-adj quaternion :inline :offset-assert 11760)
|
|
(rotate-adj-count int8 :offset-assert 11776)
|
|
(ragdoll-flags uint32 :offset-assert 11780)
|
|
(flex-blend float :offset-assert 11784)
|
|
(stable-joints int8 :offset-assert 11788)
|
|
(ragdoll-joint-remap UNKNOWN 100 :offset-assert 11789)
|
|
(allow-destabilize uint64 :offset-assert 11896)
|
|
(bg-collide-with uint32 :offset-assert 11904)
|
|
(water-info water-info :inline :offset-assert 11920)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x2ecc
|
|
:flag-assert #x1a00002ecc
|
|
(:methods
|
|
(ragdoll-method-9 () none) ;; 9
|
|
(ragdoll-method-10 () none) ;; 10
|
|
(ragdoll-method-11 () none) ;; 11
|
|
(ragdoll-method-12 () none) ;; 12
|
|
(ragdoll-method-13 () none) ;; 13
|
|
(ragdoll-method-14 () none) ;; 14
|
|
(ragdoll-method-15 () none) ;; 15
|
|
(ragdoll-method-16 () none) ;; 16
|
|
(ragdoll-method-17 () none) ;; 17
|
|
(ragdoll-method-18 () none) ;; 18
|
|
(ragdoll-method-19 () none) ;; 19
|
|
(ragdoll-method-20 () none) ;; 20
|
|
(ragdoll-method-21 () none) ;; 21
|
|
(ragdoll-method-22 () none) ;; 22
|
|
(ragdoll-method-23 () none) ;; 23
|
|
(ragdoll-method-24 () none) ;; 24
|
|
(ragdoll-method-25 () none) ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ragdoll-proc (process)
|
|
((ragdoll basic :offset-assert 128)
|
|
(last-attack-id uint32 :offset-assert 132)
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x88
|
|
:flag-assert #x1400100088
|
|
(:methods
|
|
(ragdoll-proc-method-14 () none) ;; 14
|
|
(ragdoll-proc-method-15 () none) ;; 15
|
|
(ragdoll-proc-method-16 () none) ;; 16
|
|
(ragdoll-proc-method-17 () none) ;; 17
|
|
(ragdoll-proc-method-18 () none) ;; 18
|
|
(ragdoll-proc-method-19 () none) ;; 19
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wings-ragdoll-proc (ragdoll-proc)
|
|
()
|
|
:method-count-assert 20
|
|
:size-assert #x88
|
|
:flag-assert #x1400100088
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ragdoll-edit-info* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-ocean ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ocean-colors-desert* object)
|
|
;; (define-extern *ocean-near-indices-desert* ocean-near-indices)
|
|
;; (define-extern *ocean-trans-indices-desert* ocean-trans-indices)
|
|
;; (define-extern *ocean-mid-indices-desert* ocean-mid-indices)
|
|
;; (define-extern *ocean-mid-masks-desert* ocean-mid-masks)
|
|
;; (define-extern *ocean-map-desert* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mission-squad-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype city-attacker-info (structure)
|
|
((proc uint64 :offset-assert 0)
|
|
(enemy uint64 :offset-assert 8)
|
|
(next-update-target-time uint64 :offset-assert 16)
|
|
(flags uint16 :offset-assert 24)
|
|
(num-current-attackers uint8 :offset-assert 26)
|
|
(max-num-attackers uint8 :offset-assert 27)
|
|
(self-type int16 :offset-assert 28)
|
|
(enemy-type int16 :offset-assert 30)
|
|
(self-index int16 :offset-assert 32)
|
|
(enemy-index int16 :offset-assert 34)
|
|
(callback basic :offset-assert 36)
|
|
(hatred-map-callback basic :offset-assert 40)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x2c
|
|
:flag-assert #xb0000002c
|
|
(:methods
|
|
(city-attacker-info-method-9 () none) ;; 9
|
|
(city-attacker-info-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-attacker-cache (structure)
|
|
((pos vector :offset-assert 0)
|
|
(proc basic :offset-assert 4)
|
|
(attackable? basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-hatred-info (structure)
|
|
((hatred float :offset-assert 0)
|
|
(max-consider-dist float :offset-assert 4)
|
|
(hatred-dist float :offset-assert 8)
|
|
(dist-scale float :offset-assert 12)
|
|
(attacker-scale float :offset-assert 16)
|
|
(flags uint16 :offset-assert 20)
|
|
(index uint8 :offset-assert 22)
|
|
(pad uint8 :offset-assert 23)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-attacker-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-hatred-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-attacker-cache-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mission-squad-control (basic)
|
|
((attackers basic :offset-assert 4)
|
|
(unused-list basic :offset-assert 8)
|
|
(hatred-vals basic :offset-assert 12)
|
|
(hatred-indices basic :offset-assert 16)
|
|
(attacker-cache basic :offset-assert 20)
|
|
(target-attacker city-attacker-info :offset-assert 24)
|
|
(max-num-object-types int32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x20
|
|
:flag-assert #x1800000020
|
|
(:methods
|
|
(mission-squad-control-method-9 () none) ;; 9
|
|
(mission-squad-control-method-10 () none) ;; 10
|
|
(mission-squad-control-method-11 () none) ;; 11
|
|
(mission-squad-control-method-12 () none) ;; 12
|
|
(mission-squad-control-method-13 () none) ;; 13
|
|
(mission-squad-control-method-14 () none) ;; 14
|
|
(mission-squad-control-method-15 () none) ;; 15
|
|
(mission-squad-control-method-16 () none) ;; 16
|
|
(mission-squad-control-method-17 () none) ;; 17
|
|
(mission-squad-control-method-18 () none) ;; 18
|
|
(mission-squad-control-method-19 () none) ;; 19
|
|
(mission-squad-control-method-20 () none) ;; 20
|
|
(mission-squad-control-method-21 () none) ;; 21
|
|
(mission-squad-control-method-22 () none) ;; 22
|
|
(mission-squad-control-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; projectile-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype projectile (process-drawable)
|
|
((starting-pos vector :inline :offset-assert 208)
|
|
(starting-dir vector :inline :offset-assert 224)
|
|
(target-pos vector :inline :offset-assert 240)
|
|
(base-target-pos vector :inline :offset-assert 256)
|
|
(pre-move-transv vector :inline :offset-assert 272)
|
|
(timeout uint64 :offset-assert 288) ;; time-frame
|
|
(spawn-time uint64 :offset-assert 296) ;; time-frame
|
|
(options uint64 :offset-assert 304) ;; projectile-options
|
|
(last-target uint64 :offset-assert 312) ;; handle
|
|
(notify-handle uint64 :offset-assert 320) ;; handle
|
|
(owner-handle uint64 :offset-assert 328) ;; handle
|
|
(ignore-handle uint64 :offset-assert 336) ;; handle
|
|
(update-velocity (function projectile none) :offset-assert 344) ;; guessed by decompiler
|
|
(move (function projectile none) :offset-assert 348) ;; guessed by decompiler
|
|
(pick-target (function projectile none) :offset-assert 352) ;; guessed by decompiler
|
|
(max-speed float :offset-assert 356)
|
|
(old-dist float 16 :offset-assert 360) ;; guessed by decompiler
|
|
(old-dist-count int32 :offset-assert 424)
|
|
(hits int32 :offset-assert 428)
|
|
(max-hits int32 :offset-assert 432)
|
|
(tween float :offset-assert 436)
|
|
(attack-mode symbol :offset-assert 440) ;; guessed by decompiler
|
|
(attack-id uint32 :offset-assert 444)
|
|
(damage float :offset-assert 448)
|
|
(vehicle-damage-factor float :offset-assert 452)
|
|
(vehicle-impulse-factor float :offset-assert 456)
|
|
(charge-level float :offset-assert 460)
|
|
(sound-id sound-id :offset-assert 464) ;; guessed by decompiler
|
|
(stop-speed meters :offset-assert 468)
|
|
(invinc-time uint64 :offset-assert 472) ;; time-frame
|
|
(desired-target uint64 :offset-assert 480)
|
|
(desired-target-pos vector :inline :offset-assert 496)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x200
|
|
:flag-assert #x2901800200
|
|
(:methods
|
|
(projectile-method-20 () none) ;; 20 ;; (die () _type_ :state 20)
|
|
(projectile-method-21 () none) ;; 21 ;; (dissipate () _type_ :state 21)
|
|
(projectile-method-22 () none) ;; 22 ;; (impact () _type_ :state 22)
|
|
(projectile-method-23 () none) ;; 23 ;; (moving () _type_ :state 23)
|
|
(projectile-method-24 () none) ;; 24 ;; (draw-laser-sight (_type_) none 24)
|
|
(projectile-method-25 () none) ;; 25 ;; (spawn-impact-particles (_type_) none 25)
|
|
(projectile-method-26 () none) ;; 26 ;; (spawn-shell-particles (_type_) none 26)
|
|
(projectile-method-27 () none) ;; 27 ;; (unknown-particles (_type_) none 27)
|
|
(projectile-method-28 () none) ;; 28 ;; (play-impact-sound (_type_ projectile-options) none 28)
|
|
(projectile-method-29 () none) ;; 29 ;; (stop-sound! (_type_) none 29)
|
|
(projectile-method-30 () none) ;; 30 ;; (init-proj-collision! (_type_) none 30)
|
|
(projectile-method-31 () none) ;; 31 ;; (init-proj-settings! (_type_) none 31)
|
|
(projectile-method-32 () none) ;; 32 ;; (go-moving! (_type_) none 32)
|
|
(projectile-method-33 () none) ;; 33 ;; (go-sitting! (_type_) none 33)
|
|
(projectile-method-34 () none) ;; 34 ;; (kill-projectile! (_type_) symbol 34)
|
|
(projectile-method-35 () none) ;; 35 ;; (event-handler! (_type_ process int symbol event-message-block) object 35)
|
|
(projectile-method-36 () none) ;; 36 ;; (handle-proj-hit! (_type_ process event-message-block) object 36)
|
|
(projectile-method-37 () none) ;; 37 ;; (deal-damage! (_type_ process event-message-block) symbol 37)
|
|
(projectile-method-38 () none) ;; 38 ;; (made-impact? (_type_) symbol 38)
|
|
(projectile-method-39 () none) ;; 39 ;; (play-impact-sound! (_type_) none 39)
|
|
(projectile-method-40 () none) ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype projectile-init-by-other-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(vel vector :inline :offset-assert 16)
|
|
(target-pos vector :inline :offset-assert 32)
|
|
(target-handle uint64 :offset-assert 48)
|
|
(ent entity :offset-assert 56) ;; guessed by decompiler
|
|
(charge float :offset-assert 60)
|
|
(attack-id uint32 :offset-assert 64)
|
|
(options uint64 :offset-assert 72) ;; projectile-options
|
|
(notify-handle uint64 :offset-assert 80) ;; handle
|
|
(owner-handle uint64 :offset-assert 88) ;; handle
|
|
(ignore-handle uint64 :offset-assert 96) ;; handle
|
|
(timeout uint64 :offset-assert 104) ;; time-frame
|
|
(damage float :offset-assert 112)
|
|
(vehicle-damage-factor float :offset-assert 116)
|
|
(vehicle-impulse-factor float :offset-assert 120)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x7c
|
|
:flag-assert #x90000007c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype projectile-bounce (projectile)
|
|
((played-bounce-time uint64 :offset-assert 512) ;; time-frame
|
|
(tumble-quat quaternion :inline :offset-assert 528)
|
|
(gravity float :offset-assert 544)
|
|
)
|
|
:method-count-assert 44
|
|
:size-assert #x224
|
|
:flag-assert #x2c01b00224
|
|
(:methods
|
|
(projectile-bounce-method-41 () none) ;; 41 ;; (noop (_type_) none 41)
|
|
(projectile-bounce-method-42 () none) ;; 42
|
|
(projectile-bounce-method-43 () none) ;; 43
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spawn-projectile function) ;; (function type projectile-init-by-other-params process-tree dead-pool (pointer process))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ragdoll-test ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ragdoll-test (process-focusable)
|
|
((ragdoll-proc uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xd8
|
|
:flag-assert #x21006000d8
|
|
(:state-methods
|
|
reform ;; 28
|
|
tweak ;; 29
|
|
freefall-reform ;; 30
|
|
freefall ;; 31
|
|
idle ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ragdoll-test-ragdoll-setup* object)
|
|
;; (define-extern ragdoll-test-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-attack-controller ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cty-attack-controller (mission-squad-control)
|
|
((guard-angry-hatred-info-index int8 :offset-assert 32)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x21
|
|
:flag-assert #x1800000021
|
|
)
|
|
|#
|
|
|
|
;; (define-extern city-target-type->cty-faction function)
|
|
;; (define-extern city-target-type->traffic-object-type function)
|
|
;; (define-extern symbol->city-target-type function)
|
|
;; (define-extern *cty-attack-controller* object)
|
|
;; (define-extern initialize-cty-attack-controller function)
|
|
;; (define-extern cty-attack-reset function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bsp-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bsp-node (structure)
|
|
((front int16 :offset-assert 0)
|
|
(back int16 :offset-assert 2)
|
|
(front-box-min vector4b :inline :offset-assert 4)
|
|
(front-box-max vector4b :inline :offset-assert 8)
|
|
(back-box-min vector4b :inline :offset-assert 12)
|
|
(back-box-max vector4b :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bsp-header (drawable)
|
|
((all-visible-list (pointer uint16) :offset-assert 28) ;; guessed by decompiler
|
|
(visible-list-length int16 :offset-assert 32)
|
|
(drawable-trees drawable-tree-array :offset-assert 36) ;; guessed by decompiler
|
|
(pat pointer :offset-assert 40) ;; guessed by decompiler
|
|
(pat-length int32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 19
|
|
:size-assert #x190
|
|
:flag-assert #x1300000190
|
|
(:methods
|
|
(bsp-header-method-17 () none) ;; 17 ;; (birth (_type_) none 17)
|
|
(bsp-header-method-18 () none) ;; 18 ;; (deactivate-entities (_type_) none 18)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype game-level (basic)
|
|
((master-bsp basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype view-frustum (structure)
|
|
((hither-top-left vector :inline :offset-assert 0)
|
|
(hither-top-right vector :inline :offset-assert 16)
|
|
(hither-bottom-left vector :inline :offset-assert 32)
|
|
(hither-bottom-right vector :inline :offset-assert 48)
|
|
(yon-top-left vector :inline :offset-assert 64)
|
|
(yon-top-right vector :inline :offset-assert 80)
|
|
(yon-bottom-left vector :inline :offset-assert 96)
|
|
(yon-bottom-right vector :inline :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-stats (structure)
|
|
((calls uint32 :offset-assert 0)
|
|
(spheres uint32 :offset-assert 4)
|
|
(nodes uint32 :offset-assert 8)
|
|
(frags uint32 :offset-assert 12)
|
|
(tris uint32 :offset-assert 16)
|
|
(output uint32 :offset-assert 20)
|
|
(total-target stopwatch :inline :offset-assert 28) ;; uint32 8
|
|
(target-cache-fill stopwatch :inline :offset-assert 60) ;; uint32 8
|
|
(target-ray-poly stopwatch :inline :offset-assert 92) ;; uint32 6
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x78
|
|
:flag-assert #x900000078
|
|
)
|
|
|#
|
|
|
|
;; (define-extern inspect-bsp-tree function) ;; (function bsp-header bsp-node none)
|
|
;; (define-extern map-bsp-tree function) ;; (function (function bsp-node none) bsp-header bsp-node none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hud-classes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *hud-skullgem* object) ;; (pointer hud-skullgem)
|
|
;; (define-extern *gun-arrow-table* object)
|
|
;; (define-extern activate-hud function) ;; (function target none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; maker-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-dm-robot-splash-color* curve-color-fast)
|
|
;; (define-extern *range-dm-robot-splash-alpha* curve2d-fast)
|
|
;; (define-extern *range-dm-robot-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-dm-robot-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-dm-robot-splash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-dm-robot-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-dm-robot-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-dm-robot-splash-curve-settings* object)
|
|
;; (define-extern *range-dm-final-explo-color* curve-color-fast)
|
|
;; (define-extern *range-dm-final-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-dm-final-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-dm-final-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-dm-final-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-dm-final-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-dm-final-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-dm-final-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; joint ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype art-group (art)
|
|
((info file-info :offset-assert 0) ;; guessed by decompiler
|
|
(length int32 :offset-assert 8)
|
|
(name string :offset-assert 4) ;; guessed by decompiler
|
|
(extra res-lump :offset-assert 12) ;; guessed by decompiler
|
|
(data art-element :dynamic :offset-assert 28) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x20
|
|
:flag-assert #x1000000020
|
|
(:methods
|
|
(art-group-method-14 () none) ;; 14 ;; (unlink-art! (_type_) int 14)
|
|
(art-group-method-15 () none) ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern joint-anim-login function) ;; (function joint-anim-drawable joint-anim-drawable)
|
|
;; (define-extern joint-anim-inspect-elt function) ;; (function joint-anim float joint-anim)
|
|
;; (define-extern jacc-mem-usage function) ;; (function joint-anim-compressed-control memory-usage-block int joint-anim-compressed-control)
|
|
;; (define-extern joint-control-cleanup function)
|
|
;; (define-extern joint-control-channel-eval function) ;; (function joint-control-channel float :behavior process)
|
|
;; (define-extern joint-control-channel-eval! function) ;; (function joint-control-channel (function joint-control-channel float float float float) float :behavior process)
|
|
;; (define-extern joint-control-channel-group-eval! function) ;; (function joint-control-channel art-joint-anim (function joint-control-channel float float float float) int)
|
|
;; (define-extern joint-control-channel-group! function) ;; (function joint-control-channel art-joint-anim (function joint-control-channel float float float float) int)
|
|
;; (define-extern joint-control-copy! function) ;; (function joint-control joint-control joint-control)
|
|
;; (define-extern joint-control-remap! function) ;; (function joint-control art-group art-group pair int string symbol)
|
|
;; (define-extern flatten-joint-control-to-spr function) ;; (function joint-control int)
|
|
;; (define-extern matrix-from-joint-anim-frame function) ;; (function joint-anim-compressed-control int int matrix)
|
|
;; (define-extern matrix-from-control-channel! function) ;; (function matrix joint joint-control-channel matrix)
|
|
;; (define-extern matrix-from-control-pair! function) ;; (function matrix matrix joint int matrix)
|
|
;; (define-extern matrix-from-control! function) ;; (function matrix-stack joint joint-control symbol matrix)
|
|
;; (define-extern cspace<-cspace! function) ;; (function cspace cspace matrix)
|
|
;; (define-extern cspace<-cspace-normalized! function) ;; (function cspace cspace matrix)
|
|
;; (define-extern cspace<-parent-joint! function) ;; (function cspace (pointer process-drawable) int matrix)
|
|
;; (define-extern cspace<-rot-yxy! function) ;; (function cspace transform matrix)
|
|
;; (define-extern cspace<-transform-yxy! function) ;; (function cspace transform matrix)
|
|
;; (define-extern cspace<-transformq! function) ;; (function cspace transformq matrix)
|
|
;; (define-extern cspace<-transformq+trans! function) ;; (function cspace transformq vector matrix)
|
|
;; (define-extern cspace<-transformq+world-trans! function) ;; (function cspace transformq vector matrix)
|
|
;; (define-extern cspace<-transformq+rot-offset! function) ;; (function cspace transformq vector matrix)
|
|
;; (define-extern cspace-calc-total-matrix! function) ;; (function cspace matrix matrix)
|
|
;; (define-extern cspace<-matrix-no-push-joint! function) ;; (function cspace joint-control matrix)
|
|
;; (define-extern cspace<-matrix-joint! function) ;; (function cspace matrix matrix)
|
|
;; (define-extern cspace<-parented-matrix-joint! function) ;; (function cspace matrix matrix)
|
|
;; (define-extern cspace<-parented-matrix-mirror! function) ;; (function cspace matrix matrix)
|
|
;; (define-extern cspace<-parented-matrix-joint-flip-z! function) ;; (function cspace matrix matrix)
|
|
;; (define-extern cspace<-matrix-joint-flip-z! function) ;; (function cspace matrix none)
|
|
;; (define-extern cspace<-parented-transformq-joint! function) ;; (function cspace transformq none)
|
|
;; (define-extern cspace<-parented-transformq-joint-flip-z! function) ;; (function cspace transformq none)
|
|
;; (define-extern clear-frame-accumulator function)
|
|
;; (define-extern normalize-frame-quaternions function)
|
|
;; (define-extern decompress-fixed-data-to-accumulator function) ;; function
|
|
;; (define-extern decompress-frame-data-to-accumulator function) ;; function
|
|
;; (define-extern decompress-frame-data-pair-to-accumulator function) ;; function
|
|
;; (define-extern make-joint-jump-tables function) ;; (function int)
|
|
;; (define-extern calc-animation-from-spr function) ;; (function joint-anim-frame int none)
|
|
;; (define-extern create-interpolated-joint-animation-frame function) ;; (function joint-anim-frame int joint-control int)
|
|
;; (define-extern create-interpolated2-joint-animation-frame function) ;; (function joint-anim-frame int joint-control int)
|
|
;; (define-extern *anim-manager* object) ;; art-joint-anim-manager
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dp-bipedal ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dp-bipedal-shield (shield-sphere)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x128
|
|
:flag-assert #x2b00b00128
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dp-bipedal-invis-particle-joint (structure)
|
|
((joint int16 :offset-assert 0)
|
|
(distance float :offset-assert 4)
|
|
(size float :offset-assert 8)
|
|
(spawn? basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dp-bipedal (nav-enemy)
|
|
((los los-control :inline :offset-assert 620)
|
|
(rotation-matrix matrix :inline :offset-assert 796)
|
|
(focus-dir vector :inline :offset-assert 860)
|
|
(focus-close-attack-pos vector :inline :offset-assert 876)
|
|
(focus-throw-attack-pos vector :inline :offset-assert 892)
|
|
(focus-bullseye vector :inline :offset-assert 908)
|
|
(los-source vector :inline :offset-assert 924)
|
|
(formation-position vector :inline :offset-assert 940)
|
|
(focus-formation-source vector :inline :offset-assert 956)
|
|
(dest-quat quaternion :inline :offset-assert 972)
|
|
(minimap connection-minimap :offset-assert 988)
|
|
(part-ambush basic :offset-assert 992)
|
|
(effect-rate float :offset-assert 996)
|
|
(effect-timer uint64 :offset-assert 1004)
|
|
(scared-timer uint64 :offset-assert 1012)
|
|
(close-attack-timer uint64 :offset-assert 1020)
|
|
(can-attack-throw? basic :offset-assert 1028)
|
|
(shield-handle uint64 :offset-assert 1036)
|
|
(shield-timer uint64 :offset-assert 1044)
|
|
(shield-sound-id uint32 :offset-assert 1052)
|
|
(fade-level float :offset-assert 1056)
|
|
(turret-entity basic :offset-assert 1060)
|
|
(actor-group uint32 :offset-assert 496)
|
|
(actor-group-count int32 :offset-assert 500)
|
|
(on-screen-timer uint64 :offset-assert 1076)
|
|
(valid-ground-timer uint64 :offset-assert 1084)
|
|
(knocked-focus-reset-timer uint64 :offset-assert 1092)
|
|
)
|
|
:method-count-assert 212
|
|
:size-assert #x450
|
|
:flag-assert #xd403d00450
|
|
(:methods
|
|
(dp-bipedal-method-204 () none) ;; 204
|
|
(dp-bipedal-method-205 () none) ;; 205
|
|
(dp-bipedal-method-206 () none) ;; 206
|
|
(dp-bipedal-method-207 () none) ;; 207
|
|
(dp-bipedal-method-208 () none) ;; 208
|
|
(dp-bipedal-method-209 () none) ;; 209
|
|
(dp-bipedal-method-210 () none) ;; 210
|
|
(dp-bipedal-method-211 () none) ;; 211
|
|
)
|
|
(:state-methods
|
|
dormant ;; 28
|
|
dormant-aware ;; 29
|
|
hostile-stand ;; 191
|
|
ambush ;; 47
|
|
hostile ;; 38
|
|
de-ambush ;; 190
|
|
shield-out ;; 194
|
|
shield-idle ;; 195
|
|
shield-in ;; 196
|
|
shield-explode ;; 197
|
|
attack-close ;; 192
|
|
attack-throw ;; 193
|
|
knocked ;; 31
|
|
knocked-recover ;; 32
|
|
active ;; 34
|
|
die ;; 40
|
|
turret-seek ;; 198
|
|
turret-get-on ;; 199
|
|
turret-active ;; 202
|
|
turret-active-shoot ;; 203
|
|
turret-getting-off ;; 200
|
|
turret-get-off ;; 201
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dp-bipedal-spawner (process)
|
|
((spawn-pos vector :inline :offset-assert 128)
|
|
(spawn-timer uint64 :offset-assert 144)
|
|
(enemies-spawned int32 :offset-assert 152)
|
|
(enemies-to-spawn int32 :offset-assert 156)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xa0
|
|
:flag-assert #x10002000a0
|
|
(:state-methods
|
|
idle ;; 14
|
|
die ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *dp-bipedal-formation-table* array)
|
|
;; (define-extern *dp-bipedal-invis-joint-list* array)
|
|
;; (define-extern *fact-info-dp-bipedal-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *dp-bipedal-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern region-check-has-los function)
|
|
;; (define-extern dp-bipedal-formation-post function)
|
|
;; (define-extern dp-bipedal-hostile-post function)
|
|
;; (define-extern dp-bipedal-attack-close-post function)
|
|
;; (define-extern dp-bipedal-consider-attacks function)
|
|
;; (define-extern dp-bipedal-turret-post function)
|
|
;; (define-extern dp-bipedal-turret-code function)
|
|
;; (define-extern trajectory-prediction function)
|
|
;; (define-extern dp-bipedal-spawner-event-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; stadium-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype stadium-flag-base (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:methods
|
|
(stadium-flag-base-method-21 () none) ;; 21
|
|
(stadium-flag-base-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype stadium-sails-left (stadium-flag-base)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype stadium-sails-right (stadium-flag-base)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-dark-jak-door (process-drawable)
|
|
((played-hint? basic :offset-assert 200)
|
|
(block? basic :offset-assert 204)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd0
|
|
:flag-assert #x17005000d0
|
|
(:methods
|
|
(rub-dark-jak-door-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-falling-step (process-drawable)
|
|
((mat matrix :inline :offset-assert 208)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x110
|
|
:flag-assert #x1700900110
|
|
(:state-methods
|
|
idle ;; 20
|
|
drop ;; 21
|
|
fade-in ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-rhino-door (process-focusable)
|
|
()
|
|
:method-count-assert 34
|
|
:size-assert #xd0
|
|
:flag-assert #x22005000d0
|
|
(:methods
|
|
(rub-rhino-door-method-30 () none) ;; 30
|
|
(rub-rhino-door-method-31 () none) ;; 31
|
|
(rub-rhino-door-method-32 () none) ;; 32
|
|
(rub-rhino-door-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
explode ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-tower-smoke-stda (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *rub-rhino-door-exploder-params* joint-exploder-static-params)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-cache-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collide-puss-sphere (structure)
|
|
((bsphere sphere :inline :offset-assert 0)
|
|
(bbox4w bounding-box4w :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-puss-work (structure)
|
|
((closest-pt vector :inline :offset-assert 0)
|
|
(tri-normal vector :inline :offset-assert 16)
|
|
(tri-bbox4w bounding-box4w :inline :offset-assert 32)
|
|
(spheres-bbox4w bounding-box4w :inline :offset-assert 64)
|
|
(spheres collide-puss-sphere 64 :offset-assert 96) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #xc60
|
|
:flag-assert #xb00000c60
|
|
(:methods
|
|
(collide-puss-work-method-9 () none) ;; 9 ;; (collide-puss-work-method-9 () none 9)
|
|
(collide-puss-work-method-10 () none) ;; 10 ;; (collide-puss-work-method-10 () none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-cache-tri (structure)
|
|
((vertex vector 3 :offset-assert 0) ;; guessed by decompiler
|
|
(extra-quad uint8 16 :offset-assert 48) ;; guessed by decompiler
|
|
(pat pat-surface :offset-assert 48) ;; guessed by decompiler
|
|
(collide-ptr basic :offset-assert 52)
|
|
(prim-index uint16 :offset-assert 56)
|
|
(user16 uint16 :offset-assert 58)
|
|
(user32 uint32 :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-cache-prim (structure)
|
|
((prim-core collide-prim-core :inline :offset-assert 0)
|
|
(extra-quad uint8 16 :offset-assert 32) ;; guessed by decompiler
|
|
(ccache collide-cache :offset-assert 32) ;; guessed by decompiler
|
|
(prim collide-shape-prim :offset-assert 36) ;; guessed by decompiler
|
|
(first-tri uint16 :offset-assert 40)
|
|
(num-tris uint16 :offset-assert 42)
|
|
(unused uint8 4 :offset-assert 44) ;; guessed by decompiler
|
|
(world-sphere vector :inline :offset-assert 0)
|
|
(collide-as collide-spec :offset-assert 16) ;; guessed by decompiler
|
|
(action collide-action :offset-assert 24) ;; guessed by decompiler
|
|
(prim-type int8 :offset-assert 28) ;; prim-type
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x30
|
|
:flag-assert #xb00000030
|
|
(:methods
|
|
(collide-cache-prim-method-9 () none) ;; 9 ;; (resolve-moving-sphere-tri (_type_ collide-tri-result collide-prim-core vector float collide-action) float 9)
|
|
(collide-cache-prim-method-10 () none) ;; 10 ;; (resolve-moving-sphere-sphere (_type_ collide-tri-result collide-prim-core vector float collide-action) float 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-cache (basic)
|
|
((num-tris int32 :offset-assert 4)
|
|
(num-prims int32 :offset-assert 8)
|
|
(ignore-mask pat-surface :offset-assert 12) ;; guessed by decompiler
|
|
(ignore-processes process 2 :offset-assert 16) ;; guessed by decompiler
|
|
(collide-box bounding-box :inline :offset-assert 32)
|
|
(collide-box4w bounding-box4w :inline :offset-assert 64)
|
|
(collide-with collide-spec :offset-assert 96) ;; guessed by decompiler
|
|
(unused uint32 :offset-assert 100)
|
|
(prims collide-cache-prim 100 :offset-assert 112) ;; guessed by decompiler
|
|
(tris collide-cache-tri 461 :offset-assert 4912) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x8670
|
|
:flag-assert #x1a00008670
|
|
(:methods
|
|
(collide-cache-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(collide-cache-method-10 () none) ;; 10 ;; (fill-and-probe-using-line-sphere (_type_ collide-query) float 10)
|
|
(collide-cache-method-11 () none) ;; 11 ;; (fill-and-probe-using-spheres (_type_ collide-query) symbol 11)
|
|
(collide-cache-method-12 () none) ;; 12 ;; (fill-using-bounding-box (_type_ collide-query) none 12)
|
|
(collide-cache-method-13 () none) ;; 13 ;; (fill-using-line-sphere (_type_ collide-query) none 13)
|
|
(collide-cache-method-14 () none) ;; 14 ;; (fill-using-spheres (_type_ collide-query) none 14)
|
|
(collide-cache-method-15 () none) ;; 15 ;; (reset (_type_) none 15)
|
|
(collide-cache-method-16 () none) ;; 16 ;; (probe-using-line-sphere (_type_ collide-query) float 16)
|
|
(collide-cache-method-17 () none) ;; 17 ;; (probe-using-spheres (_type_ collide-query) symbol 17)
|
|
(collide-cache-method-18 () none) ;; 18 ;; (fill-from-bg (_type_ (function collide-hash int collide-list collide-query int) (function collide-cache collide-list collide-query none) collide-query) none 18)
|
|
(collide-cache-method-19 () none) ;; 19 ;; (fill-from-fg-boxes (_type_) none 19)
|
|
(collide-cache-method-20 () none) ;; 20 ;; (fill-from-fg-line-sphere (_type_ collide-query) none 20)
|
|
(collide-cache-method-21 () none) ;; 21 ;; (fill-from-water (_type_ water-control) none 21)
|
|
(collide-cache-method-22 () none) ;; 22 ;; (collide-cache-method-22 () none 22)
|
|
(collide-cache-method-23 () none) ;; 23 ;; (collide-cache-method-23 () none 23)
|
|
(collide-cache-method-24 () none) ;; 24 ;; (collide-cache-method-24 () none 24)
|
|
(collide-cache-method-25 () none) ;; 25 ;; (collide-cache-method-25 () none 25)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-list-item (structure)
|
|
((mesh instance-tie :offset-assert 0) ;; guessed by decompiler
|
|
(inst basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-list (structure)
|
|
((num-items int32 :offset-assert 0)
|
|
(items collide-list-item 256 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x810
|
|
:flag-assert #x900000810
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *collide-cache* object) ;; collide-cache
|
|
;; (define-extern *collide-list* object) ;; collide-list
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collide-query (structure)
|
|
((best-other-tri collide-tri-result :inline :offset-assert 0)
|
|
(best-my-tri collide-tri-result :inline :offset-assert 0)
|
|
(ignore-processes process-tree 2 :offset-assert 88) ;; guessed by decompiler
|
|
(ignore-process0 process-tree :offset-assert 88) ;; guessed by decompiler
|
|
(ignore-process1 process-tree :offset-assert 92) ;; guessed by decompiler
|
|
(ignore-pat pat-surface :offset-assert 96) ;; guessed by decompiler
|
|
(collide-with collide-spec :offset-assert 100) ;; guessed by decompiler
|
|
(overlay-params uint32 3 :offset-assert 112) ;; guessed by decompiler
|
|
(bbox bounding-box :inline :offset-assert 128)
|
|
(bbox4w bounding-box4w :inline :offset-assert 160)
|
|
(bsphere sphere :inline :offset-assert 192)
|
|
(start-pos vector :inline :offset-assert 208)
|
|
(move-dist vector :inline :offset-assert 224)
|
|
(rlength vector :inline :offset-assert 240)
|
|
(exit-planes plane 2 :offset-assert 256) ;; guessed by decompiler
|
|
(radius float :offset-assert 268)
|
|
(inv-mat matrix :inline :offset-assert 288)
|
|
(spheres (inline-array sphere) :offset-assert 112) ;; guessed by decompiler
|
|
(num-spheres uint32 :offset-assert 116)
|
|
(solid-only symbol :offset-assert 120) ;; guessed by decompiler
|
|
(best-dist float :offset-assert 112)
|
|
(best-other-prim collide-shape-prim :offset-assert 116) ;; guessed by decompiler
|
|
(best-my-prim collide-shape-prim :offset-assert 120) ;; guessed by decompiler
|
|
(move-vec vector :inline :offset-assert 224)
|
|
(best-u float :offset-assert 112)
|
|
(action-mask collide-action :offset-assert 352) ;; guessed by decompiler
|
|
(local-box4w bounding-box4w :inline :offset-assert 368)
|
|
(search-box bounding-box4w :inline :offset-assert 400)
|
|
(search-vector vector4w :inline :offset-assert 432)
|
|
(instance-mat matrix :inline :offset-assert 448)
|
|
(instance-ptr basic :offset-assert 512)
|
|
(x-addr uint32 :offset-assert 516)
|
|
(x-step uint32 :offset-assert 520)
|
|
(y-addr uint32 :offset-assert 524)
|
|
(y-step uint32 :offset-assert 528)
|
|
(z-addr uint32 :offset-assert 532)
|
|
(z-step uint32 :offset-assert 536)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x21c
|
|
:flag-assert #x90000021c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *collide-test-flag* object) ;; symbol
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; shrubbery-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype billboard (drawable)
|
|
((flat adgif-shader :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x70
|
|
:flag-assert #x1100000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shrub-view-data (structure)
|
|
((data uint128 3 :offset-assert 0) ;; guessed by decompiler
|
|
(texture-giftag qword :inline :offset-assert 0) ;; gs-gif-tag :inline
|
|
(consts vector :inline :offset-assert 16)
|
|
(fog-clamp vector :inline :offset-assert 32)
|
|
(tex-start-ptr int32 :offset-assert 16)
|
|
(gifbufsum float :offset-assert 16)
|
|
(mtx-buf-ptr int32 :offset-assert 20)
|
|
(exp23 float :offset-assert 20)
|
|
(fog-0 float :offset-assert 24)
|
|
(fog-1 float :offset-assert 28)
|
|
(fog-min float :offset-assert 32)
|
|
(fog-max float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shrubbery (drawable)
|
|
((textures (inline-array adgif-shader) :offset-assert 4) ;; guessed by decompiler
|
|
(header qword :offset-assert 8)
|
|
(obj-qwc uint8 :offset-assert 12)
|
|
(vtx-qwc uint8 :offset-assert 13)
|
|
(col-qwc uint8 :offset-assert 14)
|
|
(stq-qwc uint8 :offset-assert 15)
|
|
(obj uint32 :offset-assert 16)
|
|
(vtx uint32 :offset-assert 20)
|
|
(col uint32 :offset-assert 24)
|
|
(stq uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype instance-shrubbery (instance)
|
|
((flat-normal vector :inline :offset-assert 64)
|
|
(flat-hwidth float :offset-assert 76)
|
|
(color uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x50
|
|
:flag-assert #x1100000050
|
|
)
|
|
|#
|
|
|
|
;; (deftype drawable-inline-array-instance-shrub (drawable-inline-array)
|
|
;; ()
|
|
;; :flag-assert #x1100000074
|
|
;; )
|
|
|
|
;; (deftype drawable-tree-instance-shrub (drawable-tree)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
#|
|
|
(deftype generic-shrub-fragment (drawable)
|
|
((textures (inline-array adgif-shader) :offset-assert 4) ;; guessed by decompiler
|
|
(vtx-cnt uint32 :offset-assert 8)
|
|
(cnt-qwc uint8 :offset-assert 12)
|
|
(vtx-qwc uint8 :offset-assert 13)
|
|
(col-qwc uint8 :offset-assert 14)
|
|
(stq-qwc uint8 :offset-assert 15)
|
|
(cnt uint32 :offset-assert 16)
|
|
(vtx uint32 :offset-assert 20)
|
|
(col uint32 :offset-assert 24)
|
|
(stq uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
)
|
|
|#
|
|
|
|
;; (deftype prototype-shrubbery (drawable-inline-array)
|
|
;; ()
|
|
;; :flag-assert #x1100000044
|
|
;; )
|
|
|
|
;; (deftype prototype-trans-shrubbery (prototype-shrubbery)
|
|
;; ()
|
|
;; :flag-assert #x1100000044
|
|
;; )
|
|
|
|
;; (deftype prototype-generic-shrub (drawable-group)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
#|
|
|
(deftype shrubbery-matrix (structure)
|
|
((mat matrix :inline :offset-assert 0)
|
|
(color qword :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shrub-near-packet (structure)
|
|
((matrix-tmpl dma-packet :inline :offset-assert 0)
|
|
(header-tmpl dma-packet :inline :offset-assert 16)
|
|
(stq-tmpl dma-packet :inline :offset-assert 32)
|
|
(color-tmpl dma-packet :inline :offset-assert 48)
|
|
(vertex-tmpl dma-packet :inline :offset-assert 64)
|
|
(mscal-tmpl dma-packet :inline :offset-assert 80)
|
|
(init-tmpl dma-packet :inline :offset-assert 96)
|
|
(init-data qword 8 :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype instance-shrub-work (structure)
|
|
((dummy qword 3 :offset-assert 0) ;; guessed by decompiler
|
|
(chaina qword 8 :offset-assert 48) ;; guessed by decompiler
|
|
(chainb qword 8 :offset-assert 176) ;; guessed by decompiler
|
|
(colors rgba 1024 :offset-assert 304) ;; guessed by decompiler
|
|
(matrix-tmpl qword 20 :offset-assert 4400) ;; guessed by decompiler
|
|
(count-tmpl vector4w 20 :offset-assert 4720) ;; guessed by decompiler
|
|
(mscalf-tmpl dma-packet :inline :offset-assert 5040)
|
|
(mscalf-ret-tmpl dma-packet :inline :offset-assert 5056)
|
|
(adgif-tmpl dma-gif-packet :inline :offset-assert 5072)
|
|
(billboard-tmpl dma-gif-packet :inline :offset-assert 5104)
|
|
(billboard-const vector :inline :offset-assert 5136)
|
|
(shrub-near-packets shrub-near-packet 6 :offset-assert 5152) ;; guessed by decompiler
|
|
(dma-ref dma-packet :inline :offset-assert 6016)
|
|
(dma-end dma-packet :inline :offset-assert 6032)
|
|
(wind-const vector :inline :offset-assert 6048)
|
|
(constants vector :inline :offset-assert 6064)
|
|
(color-constant vector4w :inline :offset-assert 6080)
|
|
(hmge-d vector :inline :offset-assert 6096)
|
|
(hvdf-offset vector :inline :offset-assert 6112)
|
|
(wind-force vector :inline :offset-assert 6128)
|
|
(color vector :inline :offset-assert 6144)
|
|
(bb-color vector :inline :offset-assert 6160)
|
|
(min-dist vector :inline :offset-assert 6176)
|
|
(temp-vec vector :inline :offset-assert 6192)
|
|
(guard-plane plane 4 :offset-assert 6208) ;; guessed by decompiler
|
|
(plane plane 4 :offset-assert 6272) ;; guessed by decompiler
|
|
(last uint32 4 :offset-assert 6336) ;; guessed by decompiler
|
|
(next uint32 4 :offset-assert 6352) ;; guessed by decompiler
|
|
(count uint16 4 :offset-assert 6368) ;; guessed by decompiler
|
|
(mod-count uint16 4 :offset-assert 6376) ;; guessed by decompiler
|
|
(wind-vectors uint32 :offset-assert 6384)
|
|
(instance-ptr uint32 :offset-assert 6388)
|
|
(chain-ptr uint32 :offset-assert 6392)
|
|
(chain-ptr-next uint32 :offset-assert 6396)
|
|
(stack-ptr uint32 :offset-assert 6400)
|
|
(bucket-ptr uint32 :offset-assert 6404)
|
|
(src-ptr uint32 :offset-assert 6408)
|
|
(to-spr uint32 :offset-assert 6412)
|
|
(from-spr uint32 :offset-assert 6416)
|
|
(shrub-count uint32 :offset-assert 6420)
|
|
(stack-ptr uint32 :offset-assert 6400)
|
|
(node uint32 6 :offset-assert 6428) ;; guessed by decompiler
|
|
(length uint32 6 :offset-assert 6452) ;; guessed by decompiler
|
|
(prototypes uint32 :offset-assert 6476)
|
|
(bucket-ptr uint32 :offset-assert 6404)
|
|
(start-bank uint8 20 :offset-assert 6484) ;; guessed by decompiler
|
|
(buffer-index uint32 :offset-assert 6504)
|
|
(current-spr uint32 :offset-assert 6508)
|
|
(current-mem uint32 :offset-assert 6512)
|
|
(current-shrub-near-packet uint32 :offset-assert 6516)
|
|
(current-shrub-near-trans-packet uint32 :offset-assert 6520)
|
|
(to-spr uint32 :offset-assert 6412)
|
|
(dma-buffer basic :offset-assert 6528)
|
|
(near-last uint32 :offset-assert 6532)
|
|
(near-next uint32 :offset-assert 6536)
|
|
(near-count uint32 :offset-assert 6540)
|
|
(near-trans-last uint32 :offset-assert 6544)
|
|
(near-trans-next uint32 :offset-assert 6548)
|
|
(near-trans-count uint32 :offset-assert 6552)
|
|
(last-shrubs uint32 :offset-assert 6556)
|
|
(chains uint32 :offset-assert 6560)
|
|
(flags uint32 :offset-assert 6564)
|
|
(node-count uint32 :offset-assert 6568)
|
|
(inst-count uint32 :offset-assert 6572)
|
|
(wait-from-spr uint32 :offset-assert 6576)
|
|
(wait-to-spr uint32 :offset-assert 6580)
|
|
(texture-dists uint32 :offset-assert 6584)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x19bc
|
|
:flag-assert #x9000019bc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype instance-shrub-dma (structure)
|
|
((instancea uint128 325 :offset-assert 0) ;; guessed by decompiler
|
|
(instanceb uint128 325 :offset-assert 5200) ;; guessed by decompiler
|
|
(outa uint128 128 :offset-assert 10400) ;; guessed by decompiler
|
|
(outb uint128 128 :offset-assert 12448) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38a0
|
|
:flag-assert #x9000038a0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern shrubbery-login-post-texture function) ;; (function shrubbery none)
|
|
;; (define-extern *shrub-state* object) ;; int
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tie-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tie-fragment-debug (structure)
|
|
((num-tris uint16 :offset-assert 0)
|
|
(num-dverts uint16 :offset-assert 2)
|
|
(debug-lines (array vector-array) :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tie-fragment (drawable)
|
|
((gif-ref (inline-array adgif-shader) :offset-assert 4) ;; guessed by decompiler
|
|
(point-ref uint32 :offset-assert 8)
|
|
(color-index uint16 :offset-assert 12)
|
|
(base-colors uint8 :offset-assert 14)
|
|
(tex-count uint16 :offset-assert 32)
|
|
(gif-count uint16 :offset-assert 34)
|
|
(vertex-count uint16 :offset-assert 36)
|
|
(color-count uint16 :offset-assert 38)
|
|
(dp-ref uint32 :offset-assert 40)
|
|
(dp-qwc uint32 :offset-assert 44)
|
|
(generic-ref uint32 :offset-assert 48)
|
|
(generic-count uint16 :offset-assert 52)
|
|
(normal-count uint16 :offset-assert 54)
|
|
(normal-ref uint32 :offset-assert 56)
|
|
(debug tie-fragment-debug :offset-assert 60)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x40
|
|
:flag-assert #x1100000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype instance-tie (instance)
|
|
((color-indices uint32 :offset-assert 8)
|
|
(bucket-ptr prototype-bucket-tie :offset-assert 12) ;; guessed by decompiler
|
|
(max-scale uint16 :offset-assert 38)
|
|
(rmin-scale uint16 :offset-assert 54)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x40
|
|
:flag-assert #x1100000040
|
|
)
|
|
|#
|
|
|
|
;; (deftype drawable-inline-array-instance-tie (drawable-inline-array)
|
|
;; ()
|
|
;; :flag-assert #x1100000064
|
|
;; )
|
|
|
|
#|
|
|
(deftype drawable-tree-instance-tie (drawable-tree)
|
|
((id int16 :offset-assert 0)
|
|
(bsphere vector :inline :offset-assert 12)
|
|
(length int16 :offset-assert 2)
|
|
(data drawable :dynamic :offset-assert 28) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(prototypes proxy-prototype-array-tie :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x20
|
|
:flag-assert #x1100000020
|
|
)
|
|
|#
|
|
|
|
;; (deftype prototype-tie (drawable-inline-array)
|
|
;; ()
|
|
;; :flag-assert #x1100000064
|
|
;; )
|
|
|
|
#|
|
|
(deftype tie-matrix (structure)
|
|
((mat matrix :inline :offset-assert 0)
|
|
(morph qword :inline :offset-assert 64)
|
|
(fog qword :inline :offset-assert 80)
|
|
(envmap-flag uint32 :offset-assert 80)
|
|
(guard-flag uint32 :offset-assert 84)
|
|
(vertex-alpha float :offset-assert 88)
|
|
(fog-value float :offset-assert 92)
|
|
(fixed-alpha float :offset-assert 68)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype instance-tie-work (structure)
|
|
((wind-const vector :inline :offset-assert 0)
|
|
(hmge-d vector :inline :offset-assert 16)
|
|
(hvdf-offset vector :inline :offset-assert 32)
|
|
(wind-force vector :inline :offset-assert 48)
|
|
(constant vector :inline :offset-assert 64)
|
|
(far-morph vector :inline :offset-assert 80)
|
|
(dist-test vector :inline :offset-assert 96)
|
|
(min-dist vector :inline :offset-assert 112)
|
|
(guard-plane plane 4 :offset-assert 128) ;; guessed by decompiler
|
|
(upload-color-0 dma-packet :inline :offset-assert 192)
|
|
(upload-color-1 dma-packet :inline :offset-assert 208)
|
|
(upload-color-2 dma-packet :inline :offset-assert 224)
|
|
(upload-color-ret dma-packet :inline :offset-assert 240)
|
|
(upload-color-temp dma-packet :inline :offset-assert 256)
|
|
(generic-color-0 dma-packet :inline :offset-assert 272)
|
|
(generic-color-1 dma-packet :inline :offset-assert 288)
|
|
(generic-color-end dma-packet :inline :offset-assert 304)
|
|
(envmap-color-0 dma-packet :inline :offset-assert 320)
|
|
(envmap-color-1 dma-packet :inline :offset-assert 336)
|
|
(tie-scissor-perspective-matrix matrix :inline :offset-assert 352)
|
|
(tod-env-color vector :inline :offset-assert 416)
|
|
(morph-temp vector :inline :offset-assert 432)
|
|
(fog-temp vector :inline :offset-assert 448)
|
|
(fade-temp float :offset-assert 464)
|
|
(wind-vectors uint32 :offset-assert 468)
|
|
(test-id uint32 :offset-assert 472)
|
|
(test-id2 uint32 :offset-assert 476)
|
|
(dma-buffer basic :offset-assert 480)
|
|
(to-spr uint32 :offset-assert 484)
|
|
(from-spr uint32 :offset-assert 488)
|
|
(wind-work uint32 :offset-assert 492)
|
|
(cur-vis-bits uint32 :offset-assert 496)
|
|
(end-vis-bits uint32 :offset-assert 500)
|
|
(refl-fade-fac float :offset-assert 504)
|
|
(refl-fade-end float :offset-assert 508)
|
|
(flags uint32 :offset-assert 512)
|
|
(vanish-flag uint32 :offset-assert 516)
|
|
(translucent-flag uint32 :offset-assert 520)
|
|
(wait-from-spr uint32 :offset-assert 524)
|
|
(wait-to-spr uint32 :offset-assert 528)
|
|
(use-etie symbol :offset-assert 532) ;; guessed by decompiler
|
|
(buffer-start uint32 :offset-assert 536)
|
|
(buffer-end uint32 :offset-assert 540)
|
|
(tfrag-dists uint32 :offset-assert 544)
|
|
(alpha-dists uint32 :offset-assert 548)
|
|
(water-dists uint32 :offset-assert 552)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x22c
|
|
:flag-assert #x90000022c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype instance-tie-dma (structure)
|
|
((banka instance-tie 32 :offset-assert 4) ;; guessed by decompiler
|
|
(bankb instance-tie 32 :offset-assert 2052) ;; guessed by decompiler
|
|
(outa uint128 256 :offset-assert 4096) ;; guessed by decompiler
|
|
(outb uint128 256 :offset-assert 8192) ;; guessed by decompiler
|
|
(work instance-tie-work :offset-assert 12288)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3000
|
|
:flag-assert #x900003000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-tie-work (structure)
|
|
((upload-flushe dma-packet :inline :offset-assert 0)
|
|
(upload-palette dma-packet :inline :offset-assert 16)
|
|
(upload-model-0 dma-packet :inline :offset-assert 32)
|
|
(upload-model-1 dma-packet :inline :offset-assert 48)
|
|
(upload-model-2 dma-packet :inline :offset-assert 64)
|
|
(upload-model-3 dma-packet :inline :offset-assert 80)
|
|
(upload-model-near-0 dma-packet :inline :offset-assert 96)
|
|
(upload-model-near-1 dma-packet :inline :offset-assert 112)
|
|
(upload-model-near-2 dma-packet :inline :offset-assert 128)
|
|
(upload-model-near-3 dma-packet :inline :offset-assert 144)
|
|
(upload-model-near-4 dma-packet :inline :offset-assert 160)
|
|
(envmap-palette dma-packet :inline :offset-assert 176)
|
|
(envmap-shader dma-packet :inline :offset-assert 192)
|
|
(upload-envmap-0 dma-packet :inline :offset-assert 208)
|
|
(upload-envmap-1 dma-packet :inline :offset-assert 224)
|
|
(upload-envmap-2 dma-packet :inline :offset-assert 240)
|
|
(upload-envmap-3 dma-packet :inline :offset-assert 256)
|
|
(upload-envmap-4 dma-packet :inline :offset-assert 272)
|
|
(upload-envmap-scissor-4 dma-packet :inline :offset-assert 288)
|
|
(generic-palette dma-packet :inline :offset-assert 304)
|
|
(generic-model-0 dma-packet :inline :offset-assert 320)
|
|
(generic-model-1 dma-packet :inline :offset-assert 336)
|
|
(generic-model-2 dma-packet :inline :offset-assert 352)
|
|
(model-next dma-packet :inline :offset-assert 368)
|
|
(clamp uint64 :offset-assert 384)
|
|
(prototype-array basic :offset-assert 392)
|
|
(wait-from-spr uint32 :offset-assert 396)
|
|
(wait-to-spr uint32 :offset-assert 400)
|
|
(mood mood-context :offset-assert 404)
|
|
(last uint32 16 :offset-assert 416) ;; guessed by decompiler
|
|
(next uint32 16 :offset-assert 480) ;; guessed by decompiler
|
|
(count uint16 16 :offset-assert 544) ;; guessed by decompiler
|
|
(tie-last uint32 :offset-assert 416)
|
|
(tie-next uint32 :offset-assert 480)
|
|
(tie-count uint16 :offset-assert 544)
|
|
(trans-last uint32 :offset-assert 420)
|
|
(trans-next uint32 :offset-assert 484)
|
|
(trans-count uint16 :offset-assert 546)
|
|
(water-last uint32 :offset-assert 424)
|
|
(water-next uint32 :offset-assert 488)
|
|
(water-count uint16 :offset-assert 548)
|
|
(scissor-last uint32 :offset-assert 428)
|
|
(scissor-next uint32 :offset-assert 492)
|
|
(scissor-count uint16 :offset-assert 550)
|
|
(scissor-trans-last uint32 :offset-assert 432)
|
|
(scissor-trans-next uint32 :offset-assert 496)
|
|
(scissor-trans-count uint16 :offset-assert 552)
|
|
(scissor-water-last uint32 :offset-assert 436)
|
|
(scissor-water-next uint32 :offset-assert 500)
|
|
(scissor-water-count uint16 :offset-assert 554)
|
|
(envmap-last uint32 :offset-assert 440)
|
|
(envmap-next uint32 :offset-assert 504)
|
|
(envmap-count uint16 :offset-assert 556)
|
|
(envmap-trans-last uint32 :offset-assert 444)
|
|
(envmap-trans-next uint32 :offset-assert 508)
|
|
(envmap-trans-count uint16 :offset-assert 558)
|
|
(envmap-water-last uint32 :offset-assert 448)
|
|
(envmap-water-next uint32 :offset-assert 512)
|
|
(envmap-water-count uint16 :offset-assert 560)
|
|
(envmap-scissor-last uint32 :offset-assert 452)
|
|
(envmap-scissor-next uint32 :offset-assert 516)
|
|
(envmap-scissor-count uint16 :offset-assert 562)
|
|
(envmap-scissor-trans-last uint32 :offset-assert 456)
|
|
(envmap-scissor-trans-next uint32 :offset-assert 520)
|
|
(envmap-scissor-trans-count uint16 :offset-assert 564)
|
|
(envmap-scissor-water-last uint32 :offset-assert 460)
|
|
(envmap-scissor-water-next uint32 :offset-assert 524)
|
|
(envmap-scissor-water-count uint16 :offset-assert 566)
|
|
(generic-last uint32 :offset-assert 464)
|
|
(generic-next uint32 :offset-assert 528)
|
|
(generic-count uint16 :offset-assert 568)
|
|
(generic-trans-last uint32 :offset-assert 468)
|
|
(generic-trans-next uint32 :offset-assert 532)
|
|
(generic-trans-count uint16 :offset-assert 570)
|
|
(generic-water-last uint32 :offset-assert 472)
|
|
(generic-water-next uint32 :offset-assert 536)
|
|
(generic-water-count uint16 :offset-assert 572)
|
|
(vanish-last uint32 :offset-assert 476)
|
|
(vanish-next uint32 :offset-assert 540)
|
|
(vanish-count uint16 :offset-assert 574)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x240
|
|
:flag-assert #x900000240
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-tie-dma (structure)
|
|
((colora rgba 256 :offset-assert 0) ;; guessed by decompiler
|
|
(colorb rgba 256 :offset-assert 1024) ;; guessed by decompiler
|
|
(outa uint128 256 :offset-assert 2048) ;; guessed by decompiler
|
|
(outb uint128 256 :offset-assert 6144) ;; guessed by decompiler
|
|
(geometry uint32 4 :offset-assert 10240) ;; guessed by decompiler
|
|
(next uint32 12 :offset-assert 10256) ;; guessed by decompiler
|
|
(count uint16 12 :offset-assert 10304) ;; guessed by decompiler
|
|
(counts uint32 4 :offset-assert 10328) ;; guessed by decompiler
|
|
(palette-ptr uint32 :offset-assert 10336)
|
|
(model-ptr uint32 :offset-assert 10340)
|
|
(ret-ptr uint32 :offset-assert 10344)
|
|
(length uint32 :offset-assert 10348)
|
|
(flags uint32 :offset-assert 10352)
|
|
(dma-buffer basic :offset-assert 10356)
|
|
(this-frag-count uint32 :offset-assert 10360)
|
|
(frag-count uint8 4 :offset-assert 10364) ;; guessed by decompiler
|
|
(from-spr uint32 :offset-assert 10368)
|
|
(to-spr uint32 :offset-assert 10372)
|
|
(spr-out uint32 :offset-assert 10376)
|
|
(this-count uint32 :offset-assert 10380)
|
|
(scissor-geometry uint32 :offset-assert 10240)
|
|
(near-geometry uint32 :offset-assert 10244)
|
|
(mid-geometry uint32 :offset-assert 10248)
|
|
(far-geometry uint32 :offset-assert 10252)
|
|
(scissor-frag-count uint8 :offset-assert 10364)
|
|
(near-frag-count uint8 :offset-assert 10365)
|
|
(mid-frag-count uint8 :offset-assert 10366)
|
|
(far-frag-count uint8 :offset-assert 10367)
|
|
(tie-scissor-next uint32 :offset-assert 10256)
|
|
(tie-near-next uint32 :offset-assert 10260)
|
|
(tie-mid-next uint32 :offset-assert 10264)
|
|
(tie-far-next uint32 :offset-assert 10268)
|
|
(trans-scissor-next uint32 4 :offset-assert 10256) ;; guessed by decompiler
|
|
(trans-near-next uint32 :offset-assert 10260)
|
|
(trans-mid-next uint32 :offset-assert 10264)
|
|
(trans-far-next uint32 :offset-assert 10268)
|
|
(water-scissor-next uint32 4 :offset-assert 10256) ;; guessed by decompiler
|
|
(water-near-next uint32 :offset-assert 10260)
|
|
(water-mid-next uint32 :offset-assert 10264)
|
|
(water-far-next uint32 :offset-assert 10268)
|
|
(envmap-scissor-next uint32 4 :offset-assert 10272) ;; guessed by decompiler
|
|
(envmap-near-next uint32 :offset-assert 10276)
|
|
(envmap-mid-next uint32 :offset-assert 10280)
|
|
(envmap-far-next uint32 :offset-assert 10284)
|
|
(generic-near-next uint32 :offset-assert 10288)
|
|
(generic-mid-next uint32 :offset-assert 10292)
|
|
(generic-far-next uint32 :offset-assert 10296)
|
|
(vanish-next uint32 :offset-assert 10300)
|
|
(tie-count uint16 :offset-assert 10304)
|
|
(tie-scissor-count uint16 :offset-assert 10304)
|
|
(tie-near-count uint16 :offset-assert 10306)
|
|
(tie-mid-count uint16 :offset-assert 10308)
|
|
(tie-far-count uint16 :offset-assert 10310)
|
|
(trans-count uint16 :offset-assert 10304)
|
|
(trans-scissor-count uint16 :offset-assert 10304)
|
|
(trans-near-count uint16 :offset-assert 10306)
|
|
(trans-mid-count uint16 :offset-assert 10308)
|
|
(trans-far-count uint16 :offset-assert 10310)
|
|
(water-count uint16 :offset-assert 10304)
|
|
(water-scissor-count uint16 :offset-assert 10304)
|
|
(water-near-count uint16 :offset-assert 10306)
|
|
(water-mid-count uint16 :offset-assert 10308)
|
|
(water-far-count uint16 :offset-assert 10310)
|
|
(envmap-count uint16 :offset-assert 10312)
|
|
(envmap-scissor-count uint16 :offset-assert 10312)
|
|
(envmap-near-count uint16 :offset-assert 10314)
|
|
(envmap-mid-count uint16 :offset-assert 10316)
|
|
(envmap-far-count uint16 :offset-assert 10318)
|
|
(generic-count uint16 :offset-assert 10320)
|
|
(generic-near-count uint16 :offset-assert 10320)
|
|
(generic-mid-count uint16 :offset-assert 10322)
|
|
(generic-far-count uint16 :offset-assert 10324)
|
|
(vanish-count uint16 :offset-assert 10326)
|
|
(next-clear uint32 3 :offset-assert 10256) ;; guessed by decompiler
|
|
(count-clear uint16 3 :offset-assert 10304) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2890
|
|
:flag-assert #x900002890
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *instance-tie-work-copy* object) ;; instance-tie-work
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mined-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mined-states (structure)
|
|
((filter UNKNOWN 2 :offset-assert 0)
|
|
(light UNKNOWN 2 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
;; (define-extern set-mined-filter-light! function)
|
|
;; (define-extern init-mood-mined function)
|
|
;; (define-extern update-mood-mined function)
|
|
;; (define-extern set-mined-filter! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; waswide-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern restore-wascity-speeches function)
|
|
;; (define-extern waswide-login function)
|
|
;; (define-extern waswide-activate function)
|
|
;; (define-extern waswide-deactivate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rublcst-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tfrag-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tfragment-stats (structure)
|
|
((num-tris uint16 4 :offset-assert 0) ;; guessed by decompiler
|
|
(num-dverts uint16 4 :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tfragment-debug-data (structure)
|
|
((stats tfragment-stats :inline :offset-assert 0)
|
|
(debug-lines (array vector-array) :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype generic-tfragment (structure)
|
|
((dummy int32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tfragment (drawable)
|
|
((color-index uint16 :offset-assert 6)
|
|
(debug-data tfragment-debug-data :offset-assert 8)
|
|
(color-indices uint32 :offset-assert 12)
|
|
(colors uint32 :offset-assert 12)
|
|
(dma-chain uint32 3 :offset-assert 32) ;; guessed by decompiler
|
|
(dma-common uint32 :offset-assert 32)
|
|
(dma-level-0 uint32 :offset-assert 32)
|
|
(dma-base uint32 :offset-assert 36)
|
|
(dma-level-1 uint32 :offset-assert 40)
|
|
(dma-qwc uint8 4 :offset-assert 44) ;; guessed by decompiler
|
|
(shader (inline-array adgif-shader) :offset-assert 48) ;; guessed by decompiler
|
|
(num-shaders uint8 :offset-assert 52)
|
|
(num-base-colors uint8 :offset-assert 53)
|
|
(num-level0-colors uint8 :offset-assert 54)
|
|
(num-level1-colors uint8 :offset-assert 55)
|
|
(color-offset uint8 :offset-assert 56)
|
|
(color-count uint8 :offset-assert 57)
|
|
(texture-masks-index uint16 :offset-assert 58)
|
|
(generic generic-tfragment :offset-assert 60)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x40
|
|
:flag-assert #x1100000040
|
|
)
|
|
|#
|
|
|
|
;; (deftype drawable-inline-array-tfrag (drawable-inline-array)
|
|
;; ()
|
|
;; :flag-assert #x1100000064
|
|
;; )
|
|
|
|
;; (deftype drawable-inline-array-tfrag-trans (drawable-inline-array-tfrag)
|
|
;; ()
|
|
;; :flag-assert #x11000000b4
|
|
;; )
|
|
|
|
;; (deftype drawable-inline-array-tfrag-water (drawable-inline-array-tfrag)
|
|
;; ()
|
|
;; :flag-assert #x11000000b4
|
|
;; )
|
|
|
|
;; (deftype drawable-tree-tfrag (drawable-tree)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
;; (deftype drawable-tree-tfrag-trans (drawable-tree-tfrag)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
;; (deftype drawable-tree-tfrag-water (drawable-tree-tfrag-trans)
|
|
;; ()
|
|
;; :flag-assert #x1100000020
|
|
;; )
|
|
|
|
#|
|
|
(deftype tfrag-dists (structure)
|
|
((data uint32 16 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 4 :offset-assert 0) ;; guessed by decompiler
|
|
(k0s vector 2 :offset-assert 0) ;; guessed by decompiler
|
|
(k1s vector 2 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tfrag-data (structure)
|
|
((data uint32 56 :offset-assert 0) ;; guessed by decompiler
|
|
(vector vector 14 :offset-assert 0) ;; guessed by decompiler
|
|
(fog vector :inline :offset-assert 0)
|
|
(val vector :inline :offset-assert 16)
|
|
(strgif qword :inline :offset-assert 32) ;; gs-gif-tag :inline
|
|
(fangif qword :inline :offset-assert 48) ;; gs-gif-tag :inline
|
|
(adgif qword :inline :offset-assert 64) ;; gs-gif-tag :inline
|
|
(hvdf-offset vector :inline :offset-assert 80)
|
|
(hmge-scale vector :inline :offset-assert 96)
|
|
(invh-scale vector :inline :offset-assert 112)
|
|
(ambient vector :inline :offset-assert 128)
|
|
(guard vector :inline :offset-assert 144)
|
|
(dists tfrag-dists :inline :offset-assert 160)
|
|
(k0s uint128 2 :offset-assert 160) ;; guessed by decompiler
|
|
(k1s uint128 2 :offset-assert 192) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xe0
|
|
:flag-assert #x9000000e0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tfrag-control (structure)
|
|
((num-base-points uint32 :offset-assert 0)
|
|
(num-shared-base-points uint32 :offset-assert 4)
|
|
(num-level0-points uint32 :offset-assert 8)
|
|
(num-shared-level0-points uint32 :offset-assert 12)
|
|
(num-level1-points uint32 :offset-assert 16)
|
|
(num-shared-level1-points uint32 :offset-assert 20)
|
|
(ptr-vtxdata uint32 :offset-assert 24)
|
|
(ptr-base-points uint32 :offset-assert 28)
|
|
(ptr-shared-base-points uint32 :offset-assert 32)
|
|
(ptr-level0-points uint32 :offset-assert 36)
|
|
(ptr-shared-level0-points uint32 :offset-assert 40)
|
|
(ptr-level1-points uint32 :offset-assert 44)
|
|
(ptr-shared-level1-points uint32 :offset-assert 48)
|
|
(ptr-draw-points uint32 :offset-assert 52)
|
|
(ptr-interpolated-0 uint32 :offset-assert 56)
|
|
(ptr-shared-interpolated-0 uint32 :offset-assert 60)
|
|
(ptr-interpolated1 uint32 :offset-assert 64)
|
|
(ptr-shared-interpolated1 uint32 :offset-assert 68)
|
|
(ptr-strip-data uint32 :offset-assert 72)
|
|
(ptr-texture-data uint32 :offset-assert 76)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tfrag-stats (structure)
|
|
((from int32 :offset-assert 0)
|
|
(to int32 :offset-assert 4)
|
|
(cnt int32 :offset-assert 8)
|
|
(tris int32 :offset-assert 12)
|
|
(tfaces int32 :offset-assert 16)
|
|
(tfrags int32 :offset-assert 20)
|
|
(dtris int32 :offset-assert 24)
|
|
(base-verts int32 :offset-assert 28)
|
|
(level0-verts int32 :offset-assert 32)
|
|
(level1-verts int32 :offset-assert 36)
|
|
(dma-cnt int32 :offset-assert 40)
|
|
(dma-dta int32 :offset-assert 44)
|
|
(dma-tex int32 :offset-assert 48)
|
|
(strips int32 :offset-assert 52)
|
|
(drawpoints int32 :offset-assert 56)
|
|
(vif int32 :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tfrag-packet (structure)
|
|
((tag uint128 2 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tfrag-work (structure)
|
|
((base-tmpl dma-packet :inline :offset-assert 0)
|
|
(level-0-tmpl dma-packet :inline :offset-assert 16)
|
|
(common-tmpl dma-packet :inline :offset-assert 32)
|
|
(level-1-tmpl dma-packet :inline :offset-assert 48)
|
|
(color-tmpl dma-packet :inline :offset-assert 64)
|
|
(frag-dists vector :inline :offset-assert 80)
|
|
(min-dist vector :inline :offset-assert 96)
|
|
(color-ptr vector4w :inline :offset-assert 112)
|
|
(tr-stat-tfrag tr-stat :offset-assert 128)
|
|
(tr-stat-tfrag-scissor tr-stat :offset-assert 132)
|
|
(vu1-enable-tfrag int32 :offset-assert 136)
|
|
(vu1-enable-tfrag-scissor int32 :offset-assert 140)
|
|
(cur-vis-bits uint32 :offset-assert 144)
|
|
(end-vis-bits uint32 :offset-assert 148)
|
|
(src-ptr uint32 :offset-assert 152)
|
|
(last-call uint32 :offset-assert 156)
|
|
(dma-buffer basic :offset-assert 160)
|
|
(test-id uint32 :offset-assert 164)
|
|
(wait-from-spr uint32 :offset-assert 168)
|
|
(wait-to-spr uint32 :offset-assert 172)
|
|
(near-wait-from-spr uint32 :offset-assert 176)
|
|
(near-wait-to-spr uint32 :offset-assert 180)
|
|
(max-fragment uint16 :offset-assert 184)
|
|
(min-fragment uint16 :offset-assert 186)
|
|
(texture-dists uint32 :offset-assert 188)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc0
|
|
:flag-assert #x9000000c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tfrag-dma (structure)
|
|
((banka tfragment 16 :offset-assert 4) ;; guessed by decompiler
|
|
(bankb tfragment 16 :offset-assert 1028) ;; guessed by decompiler
|
|
(outa uint128 128 :offset-assert 2048) ;; guessed by decompiler
|
|
(outb uint128 128 :offset-assert 4096) ;; guessed by decompiler
|
|
(colors rgba 2048 :offset-assert 6144) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x37fc
|
|
:flag-assert #x9000037fc
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hfrag-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; adgif-shader-array is already defined!
|
|
|
|
#|
|
|
(deftype hfrag-montage (structure)
|
|
((data UNKNOWN 16 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-bucket (structure)
|
|
((next uint32 :offset-assert 0)
|
|
(count uint16 :offset-assert 4)
|
|
(vertex-count uint16 :offset-assert 6)
|
|
(next-scissor uint32 :offset-assert 8)
|
|
(count-scissor uint16 :offset-assert 12)
|
|
(vertex-count-scissor uint16 :offset-assert 14)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (deftype hfrag-packed-index (uint16)
|
|
;; ()
|
|
;; :flag-assert #x900000002
|
|
;; )
|
|
|
|
#|
|
|
(deftype hfrag-vertex (structure)
|
|
((height uint16 :offset-assert 0)
|
|
(packed-index uint16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vert-index (structure)
|
|
((pos vector2ub :inline :offset-assert 0)
|
|
(index0 uint16 :offset-assert 2)
|
|
(index1 uint16 :offset-assert 4)
|
|
(index2 uint16 :offset-assert 6)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-poly4 (structure)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-poly9 (structure)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-poly25 (structure)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc8
|
|
:flag-assert #x9000000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-poly4-chain (structure)
|
|
((tag dma-packet :inline :offset-assert 0)
|
|
(verts UNKNOWN 4 :offset-assert 16)
|
|
(next dma-packet :inline :offset-assert 208)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xe0
|
|
:flag-assert #x9000000e0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-poly9-chain (structure)
|
|
((tag dma-packet :inline :offset-assert 0)
|
|
(verts UNKNOWN 12 :offset-assert 16)
|
|
(next dma-packet :inline :offset-assert 592)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x260
|
|
:flag-assert #x900000260
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-poly25-chain (structure)
|
|
((tag dma-packet :inline :offset-assert 0)
|
|
(verts UNKNOWN 40 :offset-assert 16)
|
|
(next dma-packet :inline :offset-assert 1936)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x7a0
|
|
:flag-assert #x9000007a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-cache-vertex (structure)
|
|
((color vector4w :inline :offset-assert 0)
|
|
(pos vector :inline :offset-assert 16)
|
|
(clip uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-cache-line (structure)
|
|
((data UNKNOWN 9 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x120
|
|
:flag-assert #x900000120
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-visbits (structure)
|
|
((data UNKNOWN 128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-gcf-control (structure)
|
|
((matrix matrix :inline :offset-assert 0)
|
|
(giftag generic-gif-tag :inline :offset-assert 64)
|
|
(adnops UNKNOWN 2 :offset-assert 80)
|
|
(num-strips uint32 :offset-assert 76)
|
|
(num-dps uint32 :offset-assert 92)
|
|
(kick-offset uint32 :offset-assert 108)
|
|
(shader gcf-shader :inline :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc0
|
|
:flag-assert #x9000000c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-gcf-ctrl (structure)
|
|
((tag dma-packet :inline :offset-assert 0)
|
|
(control hfrag-gcf-control :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xd0
|
|
:flag-assert #x9000000d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-init-packet (structure)
|
|
((init-tmpl dma-packet :inline :offset-assert 0)
|
|
(init-data UNKNOWN 8 :offset-assert 16)
|
|
(quad UNKNOWN 3 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-sprite-coord (structure)
|
|
((pos0 vector4w :inline :offset-assert 0)
|
|
(pos1 vector4w :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-montage-coord (structure)
|
|
((stq0 vector4 :inline :offset-assert 0)
|
|
(stq1 vector4 :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-sprite-packet (structure)
|
|
((sprite-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(color vector4w :inline :offset-assert 32)
|
|
(tex0 vector :inline :offset-assert 48)
|
|
(pos0 vector4w :inline :offset-assert 64)
|
|
(tex1 vector :inline :offset-assert 80)
|
|
(pos1 vector4w :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-tex-data (structure)
|
|
((quad UNKNOWN 3 :offset-assert 0)
|
|
(prims UNKNOWN 6 :offset-assert 0)
|
|
(reg-0 uint8 :offset-assert 8)
|
|
(reg-1 uint8 :offset-assert 24)
|
|
(reg-2 uint8 :offset-assert 40)
|
|
(tex0 uint64 :offset-assert 0)
|
|
(tex1 uint64 :offset-assert 16)
|
|
(texflush uint64 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-mip-packet (structure)
|
|
((mip-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(tex0-1 vector :inline :offset-assert 32)
|
|
(tex1-1 vector :inline :offset-assert 48)
|
|
(texflush vector :inline :offset-assert 64)
|
|
(color vector4w :inline :offset-assert 80)
|
|
(tex0 vector :inline :offset-assert 96)
|
|
(pos0 vector :inline :offset-assert 112)
|
|
(tex1 vector :inline :offset-assert 128)
|
|
(pos1 vector :inline :offset-assert 144)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa0
|
|
:flag-assert #x9000000a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-adgif-packet (structure)
|
|
((adgif-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(adgif-data adgif-shader :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-adgif-packet2 (structure)
|
|
((adgif-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(adgif-data adgif-shader :inline :offset-assert 32)
|
|
(texflush uint128 :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-frame (structure)
|
|
((quad UNKNOWN 4 :offset-assert 0)
|
|
(prims UNKNOWN 8 :offset-assert 0)
|
|
(reg-0 uint8 :offset-assert 8)
|
|
(reg-1 uint8 :offset-assert 24)
|
|
(reg-2 uint8 :offset-assert 40)
|
|
(reg-3 uint8 :offset-assert 56)
|
|
(frame uint64 :offset-assert 0)
|
|
(scissor uint64 :offset-assert 16)
|
|
(xyoffset uint64 :offset-assert 32)
|
|
(test uint64 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-frame-packet (structure)
|
|
((frame-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(frame-data hfrag-frame :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfragment (drawable)
|
|
((start-corner vector :inline :offset-assert 32)
|
|
(spheres uint32 :offset-assert 48)
|
|
(visids uint32 :offset-assert 52)
|
|
(shaders uint32 :offset-assert 56)
|
|
(colors basic :offset-assert 60)
|
|
(montage uint32 :offset-assert 64)
|
|
(buckets-far uint32 :offset-assert 68)
|
|
(buckets-mid uint32 :offset-assert 72)
|
|
(buckets-near uint32 :offset-assert 76)
|
|
(verts uint32 :offset-assert 80)
|
|
(pat-array uint32 :offset-assert 84)
|
|
(pat-length uint16 :offset-assert 88)
|
|
(num-buckets-far uint16 :offset-assert 90)
|
|
(num-buckets-mid uint16 :offset-assert 92)
|
|
(num-buckets-near uint16 :offset-assert 94)
|
|
(size uint32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x60
|
|
:flag-assert #x1600000060
|
|
(:methods
|
|
(hfragment-method-17 () none) ;; 17
|
|
(hfragment-method-18 () none) ;; 18
|
|
(hfragment-method-19 () none) ;; 19
|
|
(hfragment-method-20 () none) ;; 20
|
|
(hfragment-method-21 () none) ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-dma (structure)
|
|
((banka UNKNOWN 340 :offset-assert 0)
|
|
(bankb UNKNOWN 340 :offset-assert 1360)
|
|
(outa UNKNOWN 227 :offset-assert 2720)
|
|
(outb UNKNOWN 227 :offset-assert 6352)
|
|
(cache UNKNOWN 8 :offset-assert 9984)
|
|
(colors UNKNOWN 1024 :offset-assert 12288)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4000
|
|
:flag-assert #x900004000
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-work (structure)
|
|
((far-chaina UNKNOWN 6 :offset-assert 0)
|
|
(far-chainb UNKNOWN 6 :offset-assert 96)
|
|
(mid-chaina UNKNOWN 10 :offset-assert 192)
|
|
(mid-chainb UNKNOWN 10 :offset-assert 352)
|
|
(near-chaina UNKNOWN 18 :offset-assert 512)
|
|
(near-chainb UNKNOWN 18 :offset-assert 800)
|
|
(poly4-tmpl UNKNOWN 3 :offset-assert 1088)
|
|
(poly9-tmpl UNKNOWN 3 :offset-assert 1136)
|
|
(poly25-tmpl UNKNOWN 3 :offset-assert 1184)
|
|
(init-tmpl UNKNOWN 3 :offset-assert 1232)
|
|
(control-tmpl UNKNOWN 2 :offset-assert 1376)
|
|
(heights4-tmpl UNKNOWN 2 :offset-assert 1408)
|
|
(colors4-tmpl UNKNOWN 2 :offset-assert 1440)
|
|
(heights9-tmpl UNKNOWN 2 :offset-assert 1472)
|
|
(colors9-tmpl UNKNOWN 2 :offset-assert 1504)
|
|
(heights25-tmpl UNKNOWN 2 :offset-assert 1536)
|
|
(colors25-tmpl UNKNOWN 2 :offset-assert 1568)
|
|
(init-vu1-tmpl UNKNOWN 2 :offset-assert 1600)
|
|
(next-tmpl dma-packet :inline :offset-assert 1696)
|
|
(call-tmpl dma-packet :inline :offset-assert 1712)
|
|
(ret-tmpl dma-packet :inline :offset-assert 1728)
|
|
(next-scissor-tmpl dma-packet :inline :offset-assert 1744)
|
|
(ret-scissor-tmpl dma-packet :inline :offset-assert 1760)
|
|
(frame-tmpl dma-gif-packet :inline :offset-assert 1776)
|
|
(frames UNKNOWN 5 :offset-assert 1808)
|
|
(adgif-tmpl dma-gif-packet :inline :offset-assert 2128)
|
|
(adgif-tmpl2 dma-gif-packet :inline :offset-assert 2160)
|
|
(sprite-tmpl dma-gif-packet :inline :offset-assert 2192)
|
|
(mip-tmpl dma-gif-packet :inline :offset-assert 2224)
|
|
(color UNKNOWN 6 :offset-assert 2256)
|
|
(far-data hfrag-sprite-coord :inline :offset-assert 2352)
|
|
(near-data UNKNOWN 16 :offset-assert 2384)
|
|
(mip-data UNKNOWN 7 :offset-assert 2896)
|
|
(tex-data UNKNOWN 5 :offset-assert 3120)
|
|
(tex UNKNOWN 6 :offset-assert 3360)
|
|
(montage-tex-coords UNKNOWN 128 :offset-assert 3456)
|
|
(giftag generic-gif-tag :inline :offset-assert 7552)
|
|
(call-abort dma-packet :inline :offset-assert 7568)
|
|
(call-abort-vu1 dma-packet :inline :offset-assert 7584)
|
|
(shader-far adgif-shader :inline :offset-assert 7600)
|
|
(shader-mid adgif-shader :inline :offset-assert 7680)
|
|
(shader-near adgif-shader :inline :offset-assert 7760)
|
|
(stq UNKNOWN 9 :offset-assert 7840)
|
|
(shader adgif-shader :inline :offset-assert 7984)
|
|
(constants vector :inline :offset-assert 8064)
|
|
(pos-temp vector4w :inline :offset-assert 8080)
|
|
(trans-temp vector :inline :offset-assert 8080)
|
|
(dists vector :inline :offset-assert 8096)
|
|
(rdists vector :inline :offset-assert 8112)
|
|
(call-poly4-near uint32 :offset-assert 8128)
|
|
(call-poly9-mid uint32 :offset-assert 8132)
|
|
(call-poly9-near uint32 :offset-assert 8136)
|
|
(call-poly25-far uint32 :offset-assert 8140)
|
|
(call-poly25-mid uint32 :offset-assert 8144)
|
|
(dma-buffer basic :offset-assert 8148)
|
|
(base uint32 :offset-assert 8152)
|
|
(wait-to-spr uint32 :offset-assert 8156)
|
|
(wait-from-spr uint32 :offset-assert 8160)
|
|
(buffer-end uint32 :offset-assert 8164)
|
|
(subdiv-index uint32 :offset-assert 8168)
|
|
(scissor basic :offset-assert 8172)
|
|
(chain-ptr uint32 :offset-assert 8176)
|
|
(chain-ptr-next uint32 :offset-assert 8180)
|
|
(near-dist float :offset-assert 8184)
|
|
(far-dist float :offset-assert 8188)
|
|
(to-spr uint32 :offset-assert 8192)
|
|
(from-spr uint32 :offset-assert 8196)
|
|
(lowres-flag basic :offset-assert 8200)
|
|
(hfrag hfragment :inline :offset-assert 8212)
|
|
(next-far int16 :offset-assert 8304)
|
|
(next-far-mid int16 :offset-assert 8306)
|
|
(next-mid int16 :offset-assert 8308)
|
|
(next-near-mid int16 :offset-assert 8310)
|
|
(next-near int16 :offset-assert 8312)
|
|
(next-far-scissor int16 :offset-assert 8314)
|
|
(next-near-mid-scissor int16 :offset-assert 8316)
|
|
(next-near-scissor int16 :offset-assert 8318)
|
|
(count-far int16 :offset-assert 8320)
|
|
(count-far-mid int16 :offset-assert 8322)
|
|
(count-mid int16 :offset-assert 8324)
|
|
(count-near-mid int16 :offset-assert 8326)
|
|
(count-near int16 :offset-assert 8328)
|
|
(count-far-scissor int16 :offset-assert 8330)
|
|
(count-near-mid-scissor int16 :offset-assert 8332)
|
|
(count-near-scissor int16 :offset-assert 8334)
|
|
(size-far int32 :offset-assert 8336)
|
|
(size-far-mid int32 :offset-assert 8340)
|
|
(size-mid int32 :offset-assert 8344)
|
|
(size-near-mid int32 :offset-assert 8348)
|
|
(size-near int32 :offset-assert 8352)
|
|
(size-far-scissor int32 :offset-assert 8356)
|
|
(size-near-mid-scissor int32 :offset-assert 8360)
|
|
(size-near-scissor int32 :offset-assert 8364)
|
|
(size-texture int32 :offset-assert 8368)
|
|
(poly-far hfrag-poly25 :offset-assert 8372)
|
|
(poly-mid25 uint32 :offset-assert 8376)
|
|
(poly-mid uint32 :offset-assert 8380)
|
|
(poly-near uint32 :offset-assert 8384)
|
|
(far-texture uint32 :offset-assert 8388)
|
|
(near-textures UNKNOWN 16 :offset-assert 8392)
|
|
(draw-table UNKNOWN 1024 :offset-assert 8456)
|
|
(corners UNKNOWN 1024 :offset-assert 10512)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x6910
|
|
:flag-assert #x2400006910
|
|
(:methods
|
|
(hfrag-work-method-9 () none) ;; 9
|
|
(hfrag-work-method-10 () none) ;; 10
|
|
(hfrag-work-method-11 () none) ;; 11
|
|
(hfrag-work-method-12 () none) ;; 12
|
|
(hfrag-work-method-13 () none) ;; 13
|
|
(hfrag-work-method-14 () none) ;; 14
|
|
(hfrag-work-method-15 () none) ;; 15
|
|
(hfrag-work-method-16 () none) ;; 16
|
|
(hfrag-work-method-17 () none) ;; 17
|
|
(hfrag-work-method-18 () none) ;; 18
|
|
(hfrag-work-method-19 () none) ;; 19
|
|
(hfrag-work-method-20 () none) ;; 20
|
|
(hfrag-work-method-21 () none) ;; 21
|
|
(hfrag-work-method-22 () none) ;; 22
|
|
(hfrag-work-method-23 () none) ;; 23
|
|
(hfrag-work-method-24 () none) ;; 24
|
|
(hfrag-work-method-25 () none) ;; 25
|
|
(hfrag-work-method-26 () none) ;; 26
|
|
(hfrag-work-method-27 () none) ;; 27
|
|
(hfrag-work-method-28 () none) ;; 28
|
|
(hfrag-work-method-29 () none) ;; 29
|
|
(hfrag-work-method-30 () none) ;; 30
|
|
(hfrag-work-method-31 () none) ;; 31
|
|
(hfrag-work-method-32 () none) ;; 32
|
|
(hfrag-work-method-33 () none) ;; 33
|
|
(hfrag-work-method-34 () none) ;; 34
|
|
(hfrag-work-method-35 () none) ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-mip-packet-array (structure)
|
|
((data UNKNOWN 6 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c0
|
|
:flag-assert #x9000003c0
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; guard-projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype guard-shot (projectile)
|
|
((hit-actor? symbol :offset-assert 512) ;; guessed by decompiler
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
;; (define-extern guard-shot-move function) ;; (function guard-shot none)
|
|
;; (define-extern spawn-guard-projectile function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-mid ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern ocean-mid-block object) ;; vu-function
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; entity-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype entity-perm (structure)
|
|
((user-object object 2 :offset-assert 0) ;; guessed by decompiler
|
|
(user-uint64 uint64 :offset-assert 0)
|
|
(user-float float 2 :offset-assert 0) ;; guessed by decompiler
|
|
(user-int32 int32 2 :offset-assert 0) ;; guessed by decompiler
|
|
(user-uint32 uint32 2 :offset-assert 0) ;; guessed by decompiler
|
|
(user-int16 int16 4 :offset-assert 0) ;; guessed by decompiler
|
|
(user-uint16 uint16 4 :offset-assert 0) ;; guessed by decompiler
|
|
(user-int8 int8 8 :offset-assert 0) ;; guessed by decompiler
|
|
(user-uint8 uint8 8 :offset-assert 0) ;; guessed by decompiler
|
|
(status uint16 :offset-assert 8) ;; entity-perm-status
|
|
(dummy uint8 1 :offset-assert 10) ;; guessed by decompiler
|
|
(task uint8 :offset-assert 11) ;; game-task
|
|
(aid actor-id :offset-assert 12) ;; guessed by decompiler
|
|
(quad uint128 :offset-assert 0)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x10
|
|
:flag-assert #xa00000010
|
|
(:methods
|
|
(entity-perm-method-9 () none) ;; 9 ;; (update (_type_ symbol entity-perm-status) _type_ 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype entity-links (structure)
|
|
((prev-link entity-links :offset-assert 0)
|
|
(next-link entity-links :offset-assert 4)
|
|
(entity entity :offset-assert 8) ;; guessed by decompiler
|
|
(process process :offset-assert 12) ;; guessed by decompiler
|
|
(level level :offset-assert 16) ;; guessed by decompiler
|
|
(vis-id int32 :offset-assert 20)
|
|
(kill-mask task-mask :offset-assert 24)
|
|
(vis-dist meters :offset-assert 28)
|
|
(trans vector :inline :offset-assert 32)
|
|
(perm entity-perm :inline :offset-assert 48)
|
|
(status uint16 :offset-assert 56)
|
|
(aid uint32 :offset-assert 60)
|
|
(task uint8 :offset-assert 59)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x40
|
|
:flag-assert #xa00000040
|
|
(:methods
|
|
(entity-links-method-9 () none) ;; 9 ;; (birth? (_type_ vector) symbol 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype entity-perm-array (inline-array-class)
|
|
((data entity-perm :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype entity-links-array (inline-array-class)
|
|
((data entity-links :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
;; (deftype entity (res-lump)
|
|
;; ()
|
|
;; :flag-assert #x1b00000034
|
|
;; )
|
|
|
|
;; (deftype entity-camera (entity)
|
|
;; ()
|
|
;; :flag-assert #x1b00000050
|
|
;; )
|
|
|
|
;; (deftype entity-nav-mesh (entity)
|
|
;; ()
|
|
;; :flag-assert #x1d00000038
|
|
;; )
|
|
|
|
;; (deftype entity-race-mesh (entity)
|
|
;; ()
|
|
;; :flag-assert #x1d00000038
|
|
;; )
|
|
|
|
;; (deftype entity-actor (entity)
|
|
;; ()
|
|
;; :flag-assert #x2100000050
|
|
;; )
|
|
|
|
#|
|
|
(deftype actor-reference (structure)
|
|
((actor entity :offset-assert 0) ;; guessed by decompiler
|
|
(id uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype actor-group (inline-array-class)
|
|
((data actor-reference :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype entity-info (basic)
|
|
((ptype type :offset-assert 4) ;; guessed by decompiler
|
|
(pool symbol :offset-assert 8) ;; guessed by decompiler
|
|
(heap-size int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype actor-bank (basic)
|
|
((pause-dist float :offset-assert 4) ;; meters
|
|
(birth-dist float :offset-assert 8) ;; meters
|
|
(birth-max int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *generate-actor-vis* object) ;; symbol
|
|
;; (define-extern *generate-actor-vis-start* object) ;; symbol
|
|
;; (define-extern *generate-actor-vis-output* object) ;; symbol
|
|
;; (define-extern *ACTOR-bank* actor-bank) ;; actor-bank
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sewer-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sewb-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sewc-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
(electricity electricity-state :inline :offset-assert 16)
|
|
(rot float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sewd-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
(electricity electricity-state :inline :offset-assert 16)
|
|
(rot float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sewg-states (structure)
|
|
((electricity UNKNOWN 2 :offset-assert 0)
|
|
(rot float :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sewh-states (structure)
|
|
((electricity UNKNOWN 5 :offset-assert 0)
|
|
(turret-value float :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x54
|
|
:flag-assert #x900000054
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sewj-states (structure)
|
|
((rot float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sewa-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-sewer-lights function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-sewa function)
|
|
;; (define-extern init-mood-sewb function)
|
|
;; (define-extern update-mood-sewb function)
|
|
;; (define-extern init-mood-sewc function)
|
|
;; (define-extern update-mood-sewc function)
|
|
;; (define-extern init-mood-sewd function)
|
|
;; (define-extern update-mood-sewd function)
|
|
;; (define-extern set-sewd-light! function)
|
|
;; (define-extern init-mood-sewg function)
|
|
;; (define-extern update-mood-sewg function)
|
|
;; (define-extern set-sewg-electricity-scale! function)
|
|
;; (define-extern init-mood-sewh function)
|
|
;; (define-extern update-mood-sewh function)
|
|
;; (define-extern set-sewh-electricity-scale! function)
|
|
;; (define-extern set-sewh-turret-flash! function)
|
|
;; (define-extern update-mood-sewj function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sprite-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sprite-vec-data-2d (structure)
|
|
((x-y-z-sx vector :inline :offset-assert 0)
|
|
(flag-rot-sy vector :inline :offset-assert 16)
|
|
(r-g-b-a vector :inline :offset-assert 32)
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(z float :offset-assert 8)
|
|
(sx float :offset-assert 12)
|
|
(sy float :offset-assert 28)
|
|
(rot float :offset-assert 24)
|
|
(flag int32 :offset-assert 16)
|
|
(matrix int32 :offset-assert 20)
|
|
(warp-turns int32 :offset-assert 16)
|
|
(r float :offset-assert 32)
|
|
(g float :offset-assert 36)
|
|
(b float :offset-assert 40)
|
|
(a float :offset-assert 44)
|
|
(trans vector3s :inline :offset-assert 0)
|
|
(color rgbaf :inline :offset-assert 32)
|
|
(data uint128 1 :offset-assert 0) ;; guessed by decompiler
|
|
(data64 uint64 6 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-array-2d (basic)
|
|
((num-sprites int32 2 :offset-assert 4) ;; guessed by decompiler
|
|
(num-valid int32 2 :offset-assert 12) ;; guessed by decompiler
|
|
(vec-data pointer :offset-assert 20) ;; guessed by decompiler
|
|
(adgif-data (inline-array adgif-shader) :offset-assert 24) ;; guessed by decompiler
|
|
(pad uint128 4 :offset-assert 32) ;; guessed by decompiler
|
|
(data uint128 1 :offset-assert 96) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-vec-data-3d (structure)
|
|
((x-y-z-sx vector :inline :offset-assert 0)
|
|
(qx-qy-qz-sy vector :inline :offset-assert 16)
|
|
(r-g-b-a vector :inline :offset-assert 32)
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(z float :offset-assert 8)
|
|
(sx float :offset-assert 12)
|
|
(sy float :offset-assert 28)
|
|
(qx float :offset-assert 16)
|
|
(qy float :offset-assert 20)
|
|
(qz float :offset-assert 24)
|
|
(r float :offset-assert 32)
|
|
(g float :offset-assert 36)
|
|
(b float :offset-assert 40)
|
|
(a float :offset-assert 44)
|
|
(trans vector3s :inline :offset-assert 0)
|
|
(rot vector3s :inline :offset-assert 16)
|
|
(color rgbaf :inline :offset-assert 32)
|
|
(data uint128 1 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-array-3d (basic)
|
|
((num-sprites int32 2 :offset-assert 4) ;; guessed by decompiler
|
|
(num-valid int32 2 :offset-assert 12) ;; guessed by decompiler
|
|
(vec-data pointer :offset-assert 20) ;; guessed by decompiler
|
|
(adgif-data (inline-array adgif-shader) :offset-assert 24) ;; guessed by decompiler
|
|
(data uint128 1 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blow-tower-speech ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern symbol->blow-tower-speech function)
|
|
;; (define-extern *blow-tower-speech* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; waswide-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wascity-windmill (process-drawable)
|
|
((quat quaternion :inline :offset-assert 208)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xe0
|
|
:flag-assert #x15006000e0
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-flag-base (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:methods
|
|
(wascity-flag-base-method-21 () none) ;; 21
|
|
(wascity-flag-base-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-flag-a (wascity-flag-base)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-flag-b (wascity-flag-base)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-flag-c (wascity-flag-base)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-flag-d (wascity-flag-base)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-wind-fan (process-drawable)
|
|
((quat quaternion :inline :offset-assert 208)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xe0
|
|
:flag-assert #x15006000e0
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; shaker is already defined!
|
|
|
|
#|
|
|
(deftype wascity-cactus (process-focusable)
|
|
((shakers UNKNOWN 6 :offset-assert 208)
|
|
(incoming-attack-id uint32 :offset-assert 592)
|
|
(incoming-attack-time uint64 :offset-assert 600)
|
|
(hit-points float :offset-assert 608)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x264
|
|
:flag-assert #x2001f00264
|
|
(:methods
|
|
(wascity-cactus-method-30 () none) ;; 30
|
|
(wascity-cactus-method-31 () none) ;; 31
|
|
)
|
|
(:state-methods
|
|
die ;; 29
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-market-crate (market-crate)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-market-basket-a (market-basket-a)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-market-basket-b (market-basket-b)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-market-sack-a (market-sack-a)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-market-sack-b (market-sack-b)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-fruit-stand (fruit-stand)
|
|
()
|
|
:method-count-assert 31
|
|
:size-assert #x144
|
|
:flag-assert #x1f00d00144
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-water-pump (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-awning-a (bouncer)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xd8
|
|
:flag-assert #x1b006000d8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-awning-b (bouncer)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xd8
|
|
:flag-assert #x1b006000d8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype monk-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
;; (define-extern wascity-windmill-callback function)
|
|
;; (define-extern *wascity-cactus-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern wascity-cactus-callback function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-mech ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mech-shield (shield-sphere)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x128
|
|
:flag-assert #x2b00b00128
|
|
(:state-methods
|
|
shield-disabled ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern mech-shield-init-by-other function)
|
|
;; (define-extern *mech-stance-mods* surface) ;; surface
|
|
;; (define-extern *mech-walk-mods* surface) ;; surface
|
|
;; (define-extern *mech-jump-mods* surface) ;; surface
|
|
;; (define-extern *mech-punch-mods* surface) ;; surface
|
|
;; (define-extern *mech-pickup-mods* surface) ;; surface
|
|
;; (define-extern *mech-carry-walk-mods* surface) ;; surface
|
|
;; (define-extern *mech-carry-drag-mods* surface) ;; surface
|
|
;; (define-extern *mech-carry-jump-mods* surface) ;; surface
|
|
;; (define-extern target-mech-falling-anim-trans function) ;; (function none :behavior target)
|
|
;; (define-extern target-mech-mech-effect function) ;; (function target none :behavior mech)
|
|
;; (define-extern mech-on-ground? function) ;; (function symbol :behavior target)
|
|
;; (define-extern target-mech-get-off? function) ;; (function symbol :behavior target)
|
|
;; (define-extern target-mech-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-mech-bonk-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern mech-leg-ik-callback function) ;; (function joint-mod-ik matrix matrix vector object :behavior target)
|
|
;; (define-extern mech-update-ik function) ;; (function none :behavior target)
|
|
;; (define-extern target-mech-init function) ;; (function handle float symbol none :behavior target)
|
|
;; (define-extern target-mech-exit function) ;; (function none :behavior target)
|
|
;; (define-extern target-mech-effect function) ;; (function none :behavior target)
|
|
;; (define-extern target-mech-add-thrust function) ;; (function none :behavior target)
|
|
;; (define-extern target-mech-collision function) ;; (function none :behavior target)
|
|
;; (define-extern target-mech-real-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-mech-post function) ;; (function none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; debug-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern sparticle-track-root-money function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; simple-sprite-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sprite-glow-data (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(size-x float :offset-assert 12)
|
|
(size-probe float :offset-assert 16)
|
|
(z-offset float :offset-assert 20)
|
|
(rot-angle float :offset-assert 24)
|
|
(size-y float :offset-assert 28)
|
|
(color rgbaf :inline :offset-assert 32)
|
|
(fade-a float :offset-assert 48)
|
|
(fade-b float :offset-assert 52)
|
|
(tex-id texture-id :offset-assert 56) ;; guessed by decompiler
|
|
(dummy uint32 :offset-assert 60)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x40
|
|
:flag-assert #xa00000040
|
|
(:methods
|
|
(sprite-glow-data-method-9 () none) ;; 9 ;; (set-trans (_type_ vector) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype simple-sprite-system (structure)
|
|
((count int16 :offset-assert 0)
|
|
(max-count int16 :offset-assert 2)
|
|
(data (inline-array sprite-glow-data) :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x8
|
|
:flag-assert #xc00000008
|
|
(:methods
|
|
(simple-sprite-system-method-9 () none) ;; 9 ;; (add! (_type_ sprite-glow-data) none 9)
|
|
(simple-sprite-system-method-10 () none) ;; 10 ;; (draw-all-sprites! (_type_ dma-buffer) none 10)
|
|
(simple-sprite-system-method-11 () none) ;; 11 ;; (clear! (_type_) none 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; eye-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype eye (structure)
|
|
((data vector 2 :offset-assert 0) ;; guessed by decompiler
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
(lid float :offset-assert 8)
|
|
(iris-scale float :offset-assert 16)
|
|
(pupil-scale float :offset-assert 20)
|
|
(lid-scale float :offset-assert 24)
|
|
(shader-count uint32 :offset-assert 32)
|
|
(shader UNKNOWN 8 :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eye-control (structure)
|
|
((process uint64 :offset-assert 0) ;; handle
|
|
(random-time uint16 :offset-assert 8)
|
|
(bucket uint16 :offset-assert 10)
|
|
(blink float :offset-assert 12)
|
|
(shaders (inline-array adgif-shader) :offset-assert 16) ;; guessed by decompiler
|
|
(eyes UNKNOWN 2 :offset-assert 32)
|
|
(left eye :inline :offset-assert 32)
|
|
(right eye :inline :offset-assert 112)
|
|
(level-index int16 :offset-assert 192)
|
|
(high-res? basic :offset-assert 196)
|
|
(eye-slot uint8 :offset-assert 200)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x109
|
|
:flag-assert #x900000109
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eye-control-array (basic)
|
|
((data eye-control 32 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2210
|
|
:flag-assert #x900002210
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eye-work (structure)
|
|
((sprite-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(sprite-tmpl2 dma-gif-packet :inline :offset-assert 32)
|
|
(adgif-tmpl dma-gif-packet :inline :offset-assert 64)
|
|
(blink-table float 10 :offset-assert 96) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x88
|
|
:flag-assert #x900000088
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *eye-control-array* eye-control-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-debug-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *redline-table* object) ;; (pointer float)
|
|
;; (define-extern *redline-index* object) ;; int
|
|
;; (define-extern float-save-redline function) ;; (function float none)
|
|
;; (define-extern float-lookup-redline function) ;; (function float float)
|
|
;; (define-extern *blueline-table* object) ;; (pointer float)
|
|
;; (define-extern *blueline-index* object) ;; int
|
|
;; (define-extern float-save-blueline function) ;; (function float none)
|
|
;; (define-extern float-lookup-blueline function) ;; (function float float)
|
|
;; (define-extern *greenline-table* object) ;; (pointer float)
|
|
;; (define-extern *greenline-index* object) ;; int
|
|
;; (define-extern float-save-greenline function) ;; (function float none)
|
|
;; (define-extern float-lookup-greenline function) ;; (function float float)
|
|
;; (define-extern *yellowline-table* object) ;; (pointer float)
|
|
;; (define-extern *yellowline-index* object) ;; int
|
|
;; (define-extern float-save-yellowline function) ;; (function float none)
|
|
;; (define-extern float-lookup-yellowline function) ;; (function float float)
|
|
;; (define-extern *timeplot-table* object) ;; (pointer float)
|
|
;; (define-extern *timeplot-index* object) ;; int
|
|
;; (define-extern float-save-timeplot function) ;; (function float none)
|
|
;; (define-extern float-lookup-timeplot function) ;; (function float float)
|
|
;; (define-extern *cam-layout* object) ;; symbol
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dp-bipedal-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vol-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype plane-volume (structure)
|
|
((volume-type symbol :offset-assert 0) ;; guessed by decompiler
|
|
(point-count int16 :offset-assert 4)
|
|
(normal-count int16 :offset-assert 6)
|
|
(first-point vector :offset-assert 8) ;; (pointer vector)
|
|
(first-normal vector :offset-assert 12) ;; (pointer vector)
|
|
(num-planes int32 :offset-assert 16)
|
|
(plane (inline-array plane) :offset-assert 20) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x18
|
|
:flag-assert #xc00000018
|
|
(:methods
|
|
(plane-volume-method-9 () none) ;; 9 ;; (plane-volume-method-9 (_type_ symbol vector-array vector-array) plane-volume 9)
|
|
(plane-volume-method-10 () none) ;; 10 ;; (debug-draw (_type_) none 10)
|
|
(plane-volume-method-11 () none) ;; 11 ;; (point-in-vol? (_type_ vector float) symbol 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-control (basic)
|
|
((flags vol-flags :offset-assert 4) ;; guessed by decompiler
|
|
(process process-drawable :offset-assert 8) ;; guessed by decompiler
|
|
(pos-vol-count int32 :offset-assert 12)
|
|
(pos-vol plane-volume 32 :offset-assert 16) ;; guessed by decompiler
|
|
(neg-vol-count int32 :offset-assert 784)
|
|
(neg-vol plane-volume 32 :offset-assert 788) ;; guessed by decompiler
|
|
(debug-point vector-array :offset-assert 1556) ;; guessed by decompiler
|
|
(debug-normal vector-array :offset-assert 1560) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x61c
|
|
:flag-assert #xc0000061c
|
|
(:methods
|
|
;; (new (symbol type process-drawable) _type_ 0)
|
|
(vol-control-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(vol-control-method-10 () none) ;; 10 ;; (vol-control-method-10 (_type_ plane) symbol 10)
|
|
(vol-control-method-11 () none) ;; 11 ;; (should-display? (_type_) symbol 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; trail ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype trail-vis-work (structure)
|
|
((best-count uint32 :offset-assert 0)
|
|
(best-dist float :offset-assert 4)
|
|
(start-conn-id uint32 :offset-assert 8)
|
|
(p0 vector :inline :offset-assert 16)
|
|
(p1 vector :inline :offset-assert 32)
|
|
(best-node-id uint16 64 :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xb0
|
|
:flag-assert #x9000000b0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *trail-graph* object) ;; trail-graph
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; camera-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cam-index (structure)
|
|
((flags cam-index-options :offset-assert 0) ;; guessed by decompiler
|
|
(vec vector 2 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x30
|
|
:flag-assert #xb00000030
|
|
(:methods
|
|
(cam-index-method-9 () none) ;; 9 ;; (cam-index-method-9 (_type_ symbol entity vector curve) symbol 9)
|
|
(cam-index-method-10 () none) ;; 10 ;; (cam-index-method-10 (_type_ vector) float 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tracking-point (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(direction vector :inline :offset-assert 16)
|
|
(tp-length float :offset-assert 32)
|
|
(next int32 :offset-assert 36)
|
|
(incarnation int32 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tracking-spline-sampler (structure)
|
|
((cur-pt int32 :offset-assert 0)
|
|
(partial-pt float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tracking-spline (structure)
|
|
((point tracking-point 32 :offset-assert 0) ;; guessed by decompiler
|
|
(summed-len float :offset-assert 1536)
|
|
(free-point int32 :offset-assert 1540)
|
|
(used-point int32 :offset-assert 1544)
|
|
(partial-point float :offset-assert 1548)
|
|
(end-point int32 :offset-assert 1552)
|
|
(next-to-last-point int32 :offset-assert 1556)
|
|
(max-move float :offset-assert 1560)
|
|
(sample-len float :offset-assert 1564)
|
|
(used-count int32 :offset-assert 1568)
|
|
(old-position vector :inline :offset-assert 1584)
|
|
(debug-old-position vector :inline :offset-assert 1600)
|
|
(debug-out-position vector :inline :offset-assert 1616)
|
|
(debug-last-point int32 :offset-assert 1632)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x664
|
|
:flag-assert #x1800000664
|
|
(:methods
|
|
(tracking-spline-method-9 () none) ;; 9 ;; (tracking-spline-method-9 (_type_) none 9)
|
|
(tracking-spline-method-10 () none) ;; 10 ;; (tracking-spline-method-10 (_type_ vector) none 10)
|
|
(tracking-spline-method-11 () none) ;; 11 ;; (debug-point-info (_type_ int) none 11)
|
|
(tracking-spline-method-12 () none) ;; 12 ;; (debug-all-points (_type_) none 12)
|
|
(tracking-spline-method-13 () none) ;; 13 ;; (tracking-spline-method-13 (_type_ int) none 13)
|
|
(tracking-spline-method-14 () none) ;; 14 ;; (tracking-spline-method-14 (_type_ tracking-spline-sampler) none 14)
|
|
(tracking-spline-method-15 () none) ;; 15 ;; (tracking-spline-method-15 (_type_) none 15)
|
|
(tracking-spline-method-16 () none) ;; 16 ;; (tracking-spline-method-16 (_type_ float) none 16)
|
|
(tracking-spline-method-17 () none) ;; 17 ;; (tracking-spline-method-17 (_type_ vector float float symbol) int 17)
|
|
(tracking-spline-method-18 () none) ;; 18 ;; (tracking-spline-method-18 (_type_ float vector tracking-spline-sampler) vector 18)
|
|
(tracking-spline-method-19 () none) ;; 19 ;; (tracking-spline-method-19 (_type_ float vector tracking-spline-sampler) vector 19)
|
|
(tracking-spline-method-20 () none) ;; 20 ;; (tracking-spline-method-20 (_type_ vector int) none 20)
|
|
(tracking-spline-method-21 () none) ;; 21 ;; (tracking-spline-method-21 (_type_ vector float float float) vector 21)
|
|
(tracking-spline-method-22 () none) ;; 22 ;; (tracking-spline-method-22 (_type_ float) symbol 22)
|
|
(tracking-spline-method-23 () none) ;; 23 ;; (debug-draw-spline (_type_) none 23)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-float-seeker (structure)
|
|
((target float :offset-assert 0)
|
|
(value float :offset-assert 4)
|
|
(vel float :offset-assert 8)
|
|
(accel float :offset-assert 12)
|
|
(max-vel float :offset-assert 16)
|
|
(max-partial float :offset-assert 20)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x18
|
|
:flag-assert #xd00000018
|
|
(:methods
|
|
(cam-float-seeker-method-9 () none) ;; 9 ;; (init (_type_ float float float float) none 9)
|
|
(cam-float-seeker-method-10 () none) ;; 10 ;; (copy-to (_type_ _type_) none 10)
|
|
(cam-float-seeker-method-11 () none) ;; 11 ;; (update! (_type_ float) none 11)
|
|
(cam-float-seeker-method-12 () none) ;; 12 ;; (jump-to-target! (_type_ float) float 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-vector-seeker (structure)
|
|
((target vector :inline :offset-assert 0)
|
|
(value vector :inline :offset-assert 16)
|
|
(vel vector :inline :offset-assert 32)
|
|
(accel float :offset-assert 48)
|
|
(max-vel float :offset-assert 52)
|
|
(max-partial float :offset-assert 56)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x3c
|
|
:flag-assert #xb0000003c
|
|
(:methods
|
|
(cam-vector-seeker-method-9 () none) ;; 9 ;; (init (_type_ vector float float float) none 9)
|
|
(cam-vector-seeker-method-10 () none) ;; 10 ;; (update! (_type_ vector) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-rotation-tracker (structure)
|
|
((inv-mat matrix :inline :offset-assert 0)
|
|
(no-follow basic :offset-assert 64)
|
|
(follow-pt vector :inline :offset-assert 80)
|
|
(follow-off vector :inline :offset-assert 96)
|
|
(follow-blend float :offset-assert 112)
|
|
(tilt-adjust cam-float-seeker :inline :offset-assert 116)
|
|
(point-of-interest-blend cam-float-seeker :inline :offset-assert 140)
|
|
(underwater-blend cam-float-seeker :inline :offset-assert 164)
|
|
(looking-at vector :inline :offset-assert 192)
|
|
(looking-interesting vector :inline :offset-assert 208)
|
|
(old-cam-trans vector :inline :offset-assert 224)
|
|
(follow-height-extra cam-float-seeker :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x108
|
|
:flag-assert #x900000108
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype camera-combiner (process)
|
|
((trans vector :inline :offset-assert 128)
|
|
(inv-camera-rot matrix :inline :offset-assert 144)
|
|
(fov float :offset-assert 208)
|
|
(interp-val float :offset-assert 212)
|
|
(interp-step float :offset-assert 216)
|
|
(dist-from-src float :offset-assert 220)
|
|
(dist-from-dest float :offset-assert 224)
|
|
(flip-control-axis vector :inline :offset-assert 240)
|
|
(velocity vector :inline :offset-assert 256)
|
|
(tracking-status uint64 :offset-assert 272)
|
|
(tracking-options int32 :offset-assert 280)
|
|
(tracking cam-rotation-tracker :inline :offset-assert 288)
|
|
(fast-rot basic :offset-assert 552)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x22c
|
|
:flag-assert #xe01b0022c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype camera-slave (process)
|
|
((trans vector :inline :offset-assert 128)
|
|
(fov float :offset-assert 144)
|
|
(fov0 float :offset-assert 148)
|
|
(fov1 float :offset-assert 152)
|
|
(fov-index cam-index :inline :offset-assert 160)
|
|
(tracking cam-rotation-tracker :inline :offset-assert 208)
|
|
(view-off-param float :offset-assert 472)
|
|
(view-off vector :inline :offset-assert 480)
|
|
(joystick-saved-view-off vector :inline :offset-assert 496)
|
|
(min-z-override float :offset-assert 512)
|
|
(view-flat vector :inline :offset-assert 528)
|
|
(string-vel-dir uint32 :offset-assert 544)
|
|
(string-trans vector :inline :offset-assert 560)
|
|
(position-spline tracking-spline :inline :offset-assert 576)
|
|
(pivot-pt vector :inline :offset-assert 2224)
|
|
(pivot-rad float :offset-assert 2240)
|
|
(circular-follow vector :inline :offset-assert 2256)
|
|
(max-angle-offset float :offset-assert 2272)
|
|
(max-angle-curr float :offset-assert 2276)
|
|
(options cam-slave-options-u32 :offset-assert 2280) ;; guessed by decompiler
|
|
(cam-entity entity :offset-assert 2284) ;; guessed by decompiler
|
|
(butt-timer uint64 :offset-assert 2288)
|
|
(butt-seek basic :offset-assert 2296)
|
|
(butt-vector vector :inline :offset-assert 2304)
|
|
(velocity vector :inline :offset-assert 2320)
|
|
(desired-pos vector :inline :offset-assert 2336)
|
|
(time-dist-too-far uint32 :offset-assert 2352)
|
|
(los-state slave-los-state :offset-assert 2356) ;; guessed by decompiler
|
|
(good-point vector :inline :offset-assert 2368)
|
|
(los-tgt-spline-pt int32 :offset-assert 2384)
|
|
(los-tgt-spline-pt-incarnation int32 :offset-assert 2388)
|
|
(los-last-pos vector :inline :offset-assert 2400)
|
|
(intro-curve curve :inline :offset-assert 2416)
|
|
(intro-offset vector :inline :offset-assert 2448)
|
|
(intro-t float :offset-assert 2464)
|
|
(intro-t-step float :offset-assert 2468)
|
|
(outro-exit-value float :offset-assert 2472)
|
|
(spline-exists basic :offset-assert 2476)
|
|
(spline-curve curve :inline :offset-assert 2480)
|
|
(spline-offset vector :inline :offset-assert 2512)
|
|
(index cam-index :inline :offset-assert 2528)
|
|
(saved-pt vector :inline :offset-assert 2576)
|
|
(spline-tt float :offset-assert 2592)
|
|
(spline-follow-dist float :offset-assert 2596)
|
|
(enter-has-run symbol :offset-assert 2600) ;; guessed by decompiler
|
|
(blend-from-type uint64 :offset-assert 2608)
|
|
(blend-to-type uint64 :offset-assert 2616) ;; camera-blend-to-type
|
|
(have-phony-joystick basic :offset-assert 2624)
|
|
(phony-joystick-x float :offset-assert 2628)
|
|
(phony-joystick-y float :offset-assert 2632)
|
|
(string-min-val vector :inline :offset-assert 2640)
|
|
(string-max-val vector :inline :offset-assert 2656)
|
|
(string-val-locked basic :offset-assert 2672)
|
|
(relative-position vector :inline :offset-assert 2688)
|
|
(string-relative basic :offset-assert 2704)
|
|
(slope-adjust cam-float-seeker :inline :offset-assert 2708)
|
|
(slope-quat quaternion :inline :offset-assert 2736)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #xac0
|
|
:flag-assert #xe0a400ac0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype camera-master (process)
|
|
((master-options cam-master-options-u32 :offset-assert 128) ;; guessed by decompiler
|
|
(settings cam-setting-data :offset-assert 132)
|
|
(slave (pointer camera-slave) :offset-assert 136) ;; guessed by decompiler
|
|
(decel (pointer camera-slave) :offset-assert 140) ;; guessed by decompiler
|
|
(slave-options uint32 :offset-assert 144)
|
|
(view-off-param-save float :offset-assert 148)
|
|
(changer uint32 :offset-assert 152)
|
|
(string-min cam-vector-seeker :inline :offset-assert 160)
|
|
(string-max cam-vector-seeker :inline :offset-assert 224)
|
|
(string-push-z float :offset-assert 284)
|
|
(local-down vector :inline :offset-assert 288)
|
|
(focus focus :inline :offset-assert 304)
|
|
(being-attacked symbol :offset-assert 316) ;; guessed by decompiler
|
|
(attack-start uint64 :offset-assert 320) ;; time-frame
|
|
(on-ground symbol :offset-assert 328) ;; guessed by decompiler
|
|
(under-water int32 :offset-assert 332)
|
|
(on-pole symbol :offset-assert 336) ;; guessed by decompiler
|
|
(tgt-rot-mat matrix :inline :offset-assert 352)
|
|
(tgt-face-mat matrix :inline :offset-assert 416)
|
|
(tpos-old vector :inline :offset-assert 480)
|
|
(tpos-curr vector :inline :offset-assert 496)
|
|
(tpos-old-adj vector :inline :offset-assert 512)
|
|
(tpos-curr-adj vector :inline :offset-assert 528)
|
|
(tpos-tgt vector :inline :offset-assert 544)
|
|
(upspeed float :offset-assert 560)
|
|
(pitch-off vector :inline :offset-assert 576)
|
|
(target-spline tracking-spline :inline :offset-assert 592)
|
|
(ease-from vector :inline :offset-assert 2240)
|
|
(ease-t float :offset-assert 2256)
|
|
(ease-step float :offset-assert 2260)
|
|
(ease-to vector :inline :offset-assert 2272)
|
|
(outro-curve curve :inline :offset-assert 2288)
|
|
(outro-t float :offset-assert 2308)
|
|
(outro-t-step float :offset-assert 2312)
|
|
(outro-exit-value float :offset-assert 2316)
|
|
(water-drip-time uint64 :offset-assert 2320) ;; time-frame
|
|
(water-drip sparticle-launch-control :offset-assert 2328) ;; guessed by decompiler
|
|
(water-drip-mult float :offset-assert 2332)
|
|
(water-drip-speed float :offset-assert 2336)
|
|
(interest-dist float :offset-assert 2340)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x928
|
|
:flag-assert #x1108b00928
|
|
(:methods
|
|
(camera-master-method-14 () none) ;; 14 ;; (camera-master-method-14 (_type_ vector) vector 14)
|
|
(camera-master-method-15 () none) ;; 15 ;; (camera-master-method-15 (_type_ vector) vector 15)
|
|
(camera-master-method-16 () none) ;; 16 ;; (camera-master-method-16 (_type_ symbol) int 16)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; was-leaper-race-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern ocean-texture-vu1-block object) ;; vu-function
|
|
;; (define-extern check-normals function) ;; (function symbol)
|
|
;; (define-extern generate-cloud-verts function) ;; (function int float symbol)
|
|
;; (define-extern generate-cloud-nrms function) ;; (function int float symbol)
|
|
;; (define-extern set-ocean-lk function) ;; (function int int none)
|
|
;; (define-extern set-ocean-normal-scale function) ;; (function float vector)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-interface-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *camera-init-mat* object) ;; matrix
|
|
;; (define-extern *camera* object) ;; camera-master
|
|
;; (define-extern *camera-combiner* object) ;; camera-combiner
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-states-dbg ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cam-point-watch-bank (basic)
|
|
((speed float :offset-assert 4)
|
|
(rot-speed deg :offset-assert 8) ;; degrees
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-free-bank (basic)
|
|
((speed float :offset-assert 4)
|
|
(rot-speed deg :offset-assert 8) ;; degrees
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype camera-free-floating-move-info (structure)
|
|
((rv vector :inline :offset-assert 0)
|
|
(tv vector :inline :offset-assert 16)
|
|
(up vector :inline :offset-assert 32)
|
|
(tm matrix :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *CAM_POINT_WATCH-bank* cam-point-watch-bank) ;; cam-point-watch-bank
|
|
;; (define-extern cam-point-watch state) ;; (state camera-slave)
|
|
;; (define-extern *CAM_FREE-bank* cam-free-bank) ;; cam-free-bank
|
|
;; (define-extern cam-mouse-input function) ;; (function vector vector float)
|
|
;; (define-extern cam-free-floating-input function) ;; (function vector vector symbol int vector)
|
|
;; (define-extern cam-free-floating-move function) ;; (function matrix vector vector int vector)
|
|
;; (define-extern cam-free-floating state) ;; (state camera-slave)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sparticle-launcher-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sparticle-birthinfo (structure)
|
|
((sprite uint32 :offset-assert 0)
|
|
(anim int32 :offset-assert 4)
|
|
(anim-speed float :offset-assert 8)
|
|
(birth-func basic :offset-assert 12)
|
|
(joint-ppoint int32 :offset-assert 16)
|
|
(num-to-birth float :offset-assert 20)
|
|
(sound basic :offset-assert 24)
|
|
(dataf float 1 :offset-assert 0) ;; guessed by decompiler
|
|
(data uint32 1 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sp-field-init-spec (structure)
|
|
((field uint16 :offset-assert 0) ;; sp-field-id
|
|
(flags uint16 :offset-assert 2) ;; sp-flag
|
|
(initial-valuef float :offset-assert 4)
|
|
(random-rangef float :offset-assert 8)
|
|
(random-multf float :offset-assert 12)
|
|
(initial-value int32 :offset-assert 4)
|
|
(random-range int32 :offset-assert 8)
|
|
(random-mult int32 :offset-assert 12)
|
|
(func symbol :offset-assert 4) ;; guessed by decompiler
|
|
(tex texture-id :offset-assert 4) ;; guessed by decompiler
|
|
(pntr pointer :offset-assert 4) ;; guessed by decompiler
|
|
(object basic :offset-assert 4)
|
|
(sym symbol :offset-assert 4) ;; guessed by decompiler
|
|
(sound sound-spec :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
;; field object uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sparticle-launcher (basic)
|
|
((birthaccum float :offset-assert 4)
|
|
(soundaccum float :offset-assert 8)
|
|
(init-specs (inline-array sp-field-init-spec) :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x10
|
|
:flag-assert #xb00000010
|
|
(:methods
|
|
(sparticle-launcher-method-9 () none) ;; 9 ;; (get-field-spec-by-id (_type_ sp-field-id) sp-field-init-spec 9)
|
|
(sparticle-launcher-method-10 () none) ;; 10 ;; (setup-user-array (_type_ string) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sparticle-group-item (structure)
|
|
((launcher uint32 :offset-assert 0)
|
|
(fade-after meters :offset-assert 4)
|
|
(falloff-to meters :offset-assert 8)
|
|
(flags uint16 :offset-assert 12) ;; sp-group-item-flag
|
|
(period uint16 :offset-assert 14)
|
|
(length uint16 :offset-assert 16)
|
|
(offset int16 :offset-assert 18)
|
|
(hour-mask uint32 :offset-assert 20)
|
|
(binding uint32 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sparticle-launch-state (structure)
|
|
((group-item sparticle-group-item :offset-assert 0)
|
|
(flags uint16 :offset-assert 4) ;; sp-launch-state-flags
|
|
(randomize uint16 :offset-assert 6)
|
|
(center vector :offset-assert 8)
|
|
(sprite3d sprite-vec-data-3d :offset-assert 12)
|
|
(sprite sparticle-cpuinfo :offset-assert 16) ;; guessed by decompiler
|
|
(offset uint32 :offset-assert 20)
|
|
(accum float :offset-assert 24)
|
|
(spawn-time uint32 :offset-assert 28)
|
|
(control sparticle-launch-control :offset-assert 32) ;; guessed by decompiler
|
|
(swarm basic :offset-assert 20)
|
|
(seed uint32 :offset-assert 24)
|
|
(time uint32 :offset-assert 28)
|
|
(spec basic :offset-assert 16)
|
|
(id uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sparticle-launch-group (basic)
|
|
((length int16 :offset-assert 4)
|
|
(duration uint16 :offset-assert 6)
|
|
(linger-duration uint16 :offset-assert 8)
|
|
(flags uint16 :offset-assert 10) ;; sp-group-flag
|
|
(name string :offset-assert 12) ;; guessed by decompiler
|
|
(launcher (inline-array sparticle-group-item) :offset-assert 16) ;; guessed by decompiler
|
|
(rotate-x deg :offset-assert 20) ;; degrees
|
|
(rotate-y deg :offset-assert 24) ;; degrees
|
|
(rotate-z deg :offset-assert 28) ;; degrees
|
|
(scale-x float :offset-assert 32)
|
|
(scale-y float :offset-assert 36)
|
|
(scale-z float :offset-assert 40)
|
|
(bounds sphere :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x40
|
|
:flag-assert #xa00000040
|
|
(:methods
|
|
(sparticle-launch-group-method-9 () none) ;; 9 ;; (create-launch-control (_type_ process) sparticle-launch-control 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sparticle-launch-control (inline-array-class)
|
|
((group sparticle-launch-group :offset-assert 16) ;; guessed by decompiler
|
|
(proc process-drawable :offset-assert 20) ;; guessed by decompiler
|
|
(local-clock int32 :offset-assert 24)
|
|
(fade float :offset-assert 28)
|
|
(matrix int8 :offset-assert 32)
|
|
(state-mode uint8 3 :offset-assert 33) ;; guessed by decompiler
|
|
(state-counter uint32 :offset-assert 36)
|
|
(local-space-binding particle-local-space-info :offset-assert 28)
|
|
(last-spawn-frame int32 :offset-assert 40)
|
|
(last-spawn-time int32 :offset-assert 44)
|
|
(origin matrix :inline :offset-assert 48)
|
|
(center vector :inline :offset-assert 96)
|
|
(data sparticle-launch-state :dynamic :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x70
|
|
:flag-assert #x1500000070
|
|
(:methods
|
|
(sparticle-launch-control-method-14 () none) ;; 14 ;; (kill-and-free-particles (_type_) none 14)
|
|
(sparticle-launch-control-method-15 () none) ;; 15 ;; (kill-particles (_type_) none 15)
|
|
(sparticle-launch-control-method-16 () none) ;; 16
|
|
(sparticle-launch-control-method-17 () none) ;; 17
|
|
(sparticle-launch-control-method-18 () none) ;; 18
|
|
(sparticle-launch-control-method-19 () none) ;; 19
|
|
(sparticle-launch-control-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sparticle-subsampler (basic)
|
|
((spt-num float :offset-assert 4)
|
|
(sp-system basic :offset-assert 8)
|
|
(sp-launcher basic :offset-assert 12)
|
|
(spawn-mat matrix :inline :offset-assert 16)
|
|
(inited? basic :offset-assert 80)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x54
|
|
:flag-assert #xb00000054
|
|
(:methods
|
|
(sparticle-subsampler-method-9 () none) ;; 9
|
|
(sparticle-subsampler-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *launch-matrix* object) ;; matrix
|
|
;; (define-extern compute-rot-in-screenspace function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nst-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nst-water-anim (water-anim)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-metalhead-eggs (process-focusable)
|
|
((actor-group basic :offset-assert 208)
|
|
(notify-actor basic :offset-assert 212)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xd8
|
|
:flag-assert #x21006000d8
|
|
(:methods
|
|
(nst-metalhead-eggs-method-31 () none) ;; 31
|
|
(nst-metalhead-eggs-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
die-fast ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-metalhead-eggs-a (nst-metalhead-eggs)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #xd8
|
|
:flag-assert #x21006000d8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-metalhead-eggs-b (nst-metalhead-eggs)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #xd8
|
|
:flag-assert #x21006000d8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-metalhead-eggs-c (nst-metalhead-eggs)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #xd8
|
|
:flag-assert #x21006000d8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-bridge-base (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:methods
|
|
(nst-bridge-base-method-21 () none) ;; 21
|
|
(nst-bridge-base-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
nst-bridge-base-state ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-falling-stone-bridge-goo (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-falling-stone-bridge (nst-bridge-base)
|
|
((fall-anim int32 :offset-assert 200)
|
|
(goo uint32 :offset-assert 204)
|
|
(actor-group basic :offset-assert 208)
|
|
(egg-threshold uint8 :offset-assert 212)
|
|
(stop-bridge-sound basic :offset-assert 216)
|
|
(bridge-sound uint32 :offset-assert 220)
|
|
(minimap connection-minimap :offset-assert 224)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xe4
|
|
:flag-assert #x1b007000e4
|
|
(:state-methods
|
|
idle ;; 23
|
|
explode-dispatch ;; 24
|
|
falling ;; 25
|
|
grounded ;; 26
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-collapsing-stone-bridge (nst-bridge-base)
|
|
((anim basic :offset-assert 200)
|
|
(exit-anim int32 :offset-assert 204)
|
|
(bridge-type uint64 :offset-assert 208)
|
|
(stop-bridge-sound basic :offset-assert 216)
|
|
(bridge-sound uint32 :offset-assert 220)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xe0
|
|
:flag-assert #x1b006000e0
|
|
(:state-methods
|
|
idle ;; 23
|
|
collapsing ;; 24
|
|
collapsed ;; 25
|
|
collapse-fast ;; 26
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cocoon-grenade-shot (metalhead-grenade-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x214
|
|
:flag-assert #x2901a00214
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-cocoon-a (enemy)
|
|
((alt-actor basic :offset-assert 552)
|
|
(activate-distance float :offset-assert 556)
|
|
(can-shoot? basic :offset-assert 560)
|
|
(last-attack-time uint64 :offset-assert 568)
|
|
(turret joint-mod-set-world :inline :offset-assert 576)
|
|
(dest-quat quaternion :inline :offset-assert 640)
|
|
(cycling? basic :offset-assert 656)
|
|
(cycle-rot float :offset-assert 660)
|
|
(shots-left uint8 :offset-assert 664)
|
|
(cocoon-part basic :offset-assert 668)
|
|
(charge-down-part basic :offset-assert 672)
|
|
(charge-up-part basic :offset-assert 676)
|
|
(sound-turret-loop-id uint32 :offset-assert 680)
|
|
(sound-turret-loop basic :offset-assert 684)
|
|
(palette-id int32 :offset-assert 688)
|
|
(minimap connection-minimap :offset-assert 692)
|
|
)
|
|
:method-count-assert 156
|
|
:size-assert #x2b8
|
|
:flag-assert #x9c024002b8
|
|
(:methods
|
|
(nst-cocoon-a-method-155 () none) ;; 155
|
|
)
|
|
(:state-methods
|
|
notice ;; 35
|
|
hostile ;; 38
|
|
hit ;; 30
|
|
stare ;; 37
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-cocoon-b (process-drawable)
|
|
((sound-amb-loop-id uint32 :offset-assert 200)
|
|
(sound-amb-loop basic :offset-assert 204)
|
|
(gas-sound-id uint32 :offset-assert 208)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xd4
|
|
:flag-assert #x19006000d4
|
|
(:state-methods
|
|
idle ;; 20
|
|
retracting ;; 21
|
|
wait-for-cocoons ;; 22
|
|
releasing-poison ;; 23
|
|
retracted ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nst-light-barrier (process-focusable)
|
|
((pass int32 :offset-assert 208)
|
|
(incoming-attack-id uint32 :offset-assert 212)
|
|
(next-message-time uint64 :offset-assert 216)
|
|
(message int32 :offset-assert 224)
|
|
(plane plane :inline :offset-assert 240)
|
|
(color vector :inline :offset-assert 256)
|
|
(target-pos vector :inline :offset-assert 272)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #x120
|
|
:flag-assert #x1f00a00120
|
|
(:methods
|
|
(nst-light-barrier-method-29 () none) ;; 29
|
|
(nst-light-barrier-method-30 () none) ;; 30
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern ripple-for-nst-water-anim ripple-wave-set)
|
|
;; (define-extern *nst-metalhead-eggs-last-sound-time* object)
|
|
;; (define-extern *nst-falling-stone-bridge-goo-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern nst-falling-stone-bridge-goo-init-by-other function)
|
|
;; (define-extern *nst-falling-stone-bridge-part-nodes* array)
|
|
;; (define-extern sound-exit function)
|
|
;; (define-extern *nst-bridge-break-anims* array)
|
|
;; (define-extern *nst-bridge-break-exit-anims* array)
|
|
;; (define-extern *nst-cocoon-a-enemy-info* enemy-info)
|
|
;; (define-extern *nst-cocoon-a-goop-joints* array)
|
|
;; (define-extern *nst-cocoon-a-exploder-params* joint-exploder-static-params)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sparticle-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sparticle-cpuinfo (structure)
|
|
((sprite sprite-vec-data-2d :offset-assert 0)
|
|
(adgif adgif-shader :offset-assert 4)
|
|
(radius float :offset-assert 8)
|
|
(omega float :offset-assert 12)
|
|
(vel-sxvel vector :inline :offset-assert 16)
|
|
(rot-syvel vector :inline :offset-assert 32)
|
|
(fade rgbaf :inline :offset-assert 48)
|
|
(acc vector :inline :offset-assert 64)
|
|
(rotvel3d quaternion :inline :offset-assert 80)
|
|
(vel vector3s :inline :offset-assert 16) ;; vector :inline
|
|
(accel vector3s :inline :offset-assert 64) ;; vector :inline
|
|
(scalevelx float :offset-assert 28)
|
|
(scalevely float :offset-assert 44)
|
|
(friction float :offset-assert 96)
|
|
(timer int32 :offset-assert 100)
|
|
(flags sp-cpuinfo-flag :offset-assert 104) ;; guessed by decompiler
|
|
(user-int32 int32 :offset-assert 108)
|
|
(user-uint32 uint32 :offset-assert 108)
|
|
(user-float float :offset-assert 108)
|
|
(user-pntr uint32 :offset-assert 108)
|
|
(user-object basic :offset-assert 108)
|
|
(user-sprite sprite-vec-data-2d :offset-assert 108)
|
|
(sp-func (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d uint none) :offset-assert 112) ;; guessed by decompiler
|
|
(next-time uint32 :offset-assert 116)
|
|
(next-launcher basic :offset-assert 120)
|
|
(cache-alpha float :offset-assert 124)
|
|
(valid uint8 :offset-assert 128)
|
|
(clock-index uint8 :offset-assert 129)
|
|
(user1-int16 uint16 :offset-assert 130)
|
|
(key sparticle-launch-control :offset-assert 132) ;; guessed by decompiler
|
|
(binding sparticle-launch-state :offset-assert 136)
|
|
(data uint32 1 :offset-assert 12) ;; guessed by decompiler
|
|
(datab int8 4 :offset-assert 12) ;; guessed by decompiler
|
|
(dataf float 1 :offset-assert 12) ;; guessed by decompiler
|
|
(datac uint8 1 :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8c
|
|
:flag-assert #x90000008c
|
|
;; field user-object uses ~A with a signed load. field key uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sparticle-launchinfo (structure)
|
|
((launchrot vector :inline :offset-assert 0)
|
|
(conerot vector :inline :offset-assert 16)
|
|
(rotate-x float :offset-assert 32)
|
|
(rotate-y float :offset-assert 36)
|
|
(rotate-z float :offset-assert 40)
|
|
(coneradius float :offset-assert 44)
|
|
(rotate vector :inline :offset-assert 32)
|
|
(scale-x float :offset-assert 48)
|
|
(scale-y float :offset-assert 52)
|
|
(scale-z float :offset-assert 56)
|
|
(dummy float :offset-assert 60)
|
|
(scale vector :inline :offset-assert 48)
|
|
(data uint8 1 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sparticle-system (basic)
|
|
((blocks int32 2 :offset-assert 4) ;; guessed by decompiler
|
|
(length int32 2 :offset-assert 12) ;; guessed by decompiler
|
|
(num-alloc int32 2 :offset-assert 20) ;; guessed by decompiler
|
|
(is-3d basic :offset-assert 28)
|
|
(flags uint32 :offset-assert 32)
|
|
(alloc-table (pointer uint64) :offset-assert 36) ;; guessed by decompiler
|
|
(cpuinfo-table (inline-array sparticle-cpuinfo) :offset-assert 40) ;; guessed by decompiler
|
|
(vecdata-table pointer :offset-assert 44) ;; guessed by decompiler
|
|
(adgifdata-table (inline-array adgif-shader) :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *sp-60-hz* object) ;; symbol
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; actor-link-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype actor-link-info (basic)
|
|
((process process :offset-assert 4) ;; guessed by decompiler
|
|
(next entity-actor :offset-assert 8) ;; guessed by decompiler
|
|
(prev entity-actor :offset-assert 12) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x10
|
|
:flag-assert #x1a00000010
|
|
(:methods
|
|
;; (new (symbol type process symbol) _type_ 0)
|
|
(actor-link-info-method-9 () none) ;; 9 ;; (get-matching-actor-type-mask (_type_ type) int 9)
|
|
(actor-link-info-method-10 () none) ;; 10 ;; (actor-count-before (_type_) int 10)
|
|
(actor-link-info-method-11 () none) ;; 11 ;; (link-to-next-and-prev-actor (_type_) actor-link-info 11)
|
|
(actor-link-info-method-12 () none) ;; 12 ;; (get-next (_type_) entity-actor 12)
|
|
(actor-link-info-method-13 () none) ;; 13 ;; (get-prev (_type_) entity-actor 13)
|
|
(actor-link-info-method-14 () none) ;; 14 ;; (get-next-process (_type_) process 14)
|
|
(actor-link-info-method-15 () none) ;; 15 ;; (get-prev-process (_type_) process 15)
|
|
(actor-link-info-method-16 () none) ;; 16 ;; (apply-function-forward (_type_ (function entity-actor object object) object) int 16)
|
|
(actor-link-info-method-17 () none) ;; 17 ;; (apply-function-reverse (_type_ (function entity-actor object object) object) int 17)
|
|
(actor-link-info-method-18 () none) ;; 18 ;; (apply-all (_type_ (function entity-actor object object) object) int 18)
|
|
(actor-link-info-method-19 () none) ;; 19 ;; (send-to-all (_type_ symbol) none 19)
|
|
(actor-link-info-method-20 () none) ;; 20 ;; (send-to-all-after (_type_ symbol) object 20)
|
|
(actor-link-info-method-21 () none) ;; 21 ;; (send-to-all-before (_type_ symbol) object 21)
|
|
(actor-link-info-method-22 () none) ;; 22 ;; (send-to-next-and-prev (_type_ symbol) none 22)
|
|
(actor-link-info-method-23 () none) ;; 23 ;; (send-to-next (_type_ symbol) none 23)
|
|
(actor-link-info-method-24 () none) ;; 24 ;; (send-to-prev (_type_ symbol) none 24)
|
|
(actor-link-info-method-25 () none) ;; 25 ;; (actor-count (_type_) int 25)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern entity-actor-lookup function) ;; (function res-lump symbol int entity-actor)
|
|
;; (define-extern entity-actor-count function) ;; (function res-lump symbol int)
|
|
;; (define-extern actor-link-subtask-complete-hook function) ;; (function entity-actor (pointer symbol) symbol)
|
|
;; (define-extern actor-link-subtask-incomplete-count-hook function) ;; (function entity-actor (pointer uint64) symbol)
|
|
;; (define-extern actor-link-dead-hook function) ;; (function entity-actor (pointer symbol) symbol)
|
|
;; (define-extern alt-actor-list-subtask-incomplete-count function) ;; (function process-drawable int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-enemy ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *current-hover-id* object)
|
|
;; (define-extern hover-enemy-dest-post function) ;; (function none :behavior hover-enemy)
|
|
;; (define-extern hover-enemy-hostile-post function) ;; (function none :behavior hover-enemy)
|
|
;; (define-extern hover-enemy-fly-code function) ;; (function none :behavior hover-enemy)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sig-rider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sig-rider (process-focusable)
|
|
((front-back-interp float :offset-assert 208)
|
|
(left-right-interp float :offset-assert 212)
|
|
(up-down-interp float :offset-assert 216)
|
|
(complain-time uint64 :offset-assert 224)
|
|
(complain-speech int32 :offset-assert 232)
|
|
(last-moved-time uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #xf8
|
|
:flag-assert #x1e008000f8
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sig-pilot-trans function)
|
|
;; (define-extern sig-pilot-wcar-anim-loop function)
|
|
;; (define-extern sig-rider-init-by-other function)
|
|
;; (define-extern sig-rider-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bombbot-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bombbot-node (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(nav-mesh-id uint32 :offset-assert 16)
|
|
(pos-x float :offset-assert 0)
|
|
(pos-y float :offset-assert 4)
|
|
(pos-z float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bombbot-path (structure)
|
|
((node-count uint16 :offset-assert 0)
|
|
(node (inline-array bombbot-node) :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-update-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *external-cam-options* object) ;; external-cam-option
|
|
;; (define-extern *external-cam-mode* object) ;; symbol
|
|
;; (define-extern *camera-look-through-other* object) ;; int
|
|
;; (define-extern *camera-other-fov* bfloat) ;; bfloat
|
|
;; (define-extern *camera-other-trans* object) ;; vector
|
|
;; (define-extern *camera-other-matrix* object) ;; matrix
|
|
;; (define-extern *camera-smush-control* object) ;; smush-control
|
|
;; (define-extern *camera-smush-control-horizontal* object)
|
|
;; (define-extern *camera-smush-control-into* object)
|
|
;; (define-extern *camera-other-root* object) ;; vector
|
|
;; (define-extern *fix-visible-level-mask* object) ;; int
|
|
;; (define-extern *manual-sample-point* object) ;; symbol
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; railx-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern railx-death-precursor death-info)
|
|
;; (define-extern start-railx-precursor-effect function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; shrubbery ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dma-test (structure)
|
|
((data qword 101 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x650
|
|
:flag-assert #x900000650
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dma-test-work (structure)
|
|
((upload dma-packet :inline :offset-assert 0)
|
|
(end dma-packet :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prototype-shrubbery (drawable-inline-array)
|
|
((length int16 :offset-assert 2)
|
|
(data shrubbery :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x44
|
|
:flag-assert #x1100000044
|
|
)
|
|
|#
|
|
|
|
;; (define-extern mem-usage-shrub-walk function) ;; (function draw-node int memory-usage-block int draw-node)
|
|
;; (define-extern highres-shrub-login function)
|
|
;; (define-extern shrub-vu1-block object) ;; vu-function
|
|
;; (define-extern shrub-num-tris function) ;; (function shrubbery uint)
|
|
;; (define-extern shrub-make-perspective-matrix function) ;; (function matrix matrix matrix)
|
|
;; (define-extern shrub-init-view-data function) ;; (function shrub-view-data symbol)
|
|
;; (define-extern shrub-upload-view-data function) ;; (function dma-buffer symbol)
|
|
;; (define-extern shrub-time function) ;; (function int int int int int int)
|
|
;; (define-extern shrub-do-init-frame function) ;; (function dma-buffer symbol)
|
|
;; (define-extern shrub-init-frame function) ;; (function dma-buffer gs-test symbol)
|
|
;; (define-extern shrub-upload-model function) ;; (function shrubbery dma-buffer int symbol)
|
|
;; (define-extern draw-inline-array-instance-shrub function) ;; (function dma-buffer drawable int (inline-array prototype-bucket-shrub) none)
|
|
;; (define-extern draw-prototype-inline-array-shrub function) ;; (function int (inline-array prototype-bucket-shrub) pointer)
|
|
;; (define-extern draw-drawable-tree-instance-shrub function) ;; (function drawable-tree-instance-shrub level none)
|
|
;; (define-extern *dma-test* object) ;; dma-test
|
|
;; (define-extern *dma-test-work* object) ;; dma-test-work
|
|
;; (define-extern init-dma-test function) ;; (function none)
|
|
;; (define-extern dma-test-func function) ;; (function none)
|
|
;; (define-extern move-test-func function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-util ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype target-bank (basic)
|
|
((jump-collide-offset meters :offset-assert 4)
|
|
(jump-height-min meters :offset-assert 8)
|
|
(jump-height-max meters :offset-assert 12)
|
|
(double-jump-height-min meters :offset-assert 16)
|
|
(double-jump-height-max meters :offset-assert 20)
|
|
(flip-jump-height-min meters :offset-assert 24)
|
|
(flip-jump-height-max meters :offset-assert 28)
|
|
(duck-jump-height-min meters :offset-assert 32)
|
|
(duck-jump-height-max meters :offset-assert 36)
|
|
(flop-jump-height-min meters :offset-assert 40)
|
|
(flop-jump-height-max meters :offset-assert 44)
|
|
(attack-jump-height-min meters :offset-assert 48)
|
|
(attack-jump-height-max meters :offset-assert 52)
|
|
(edge-grab-jump-height-min meters :offset-assert 56)
|
|
(edge-grab-jump-height-max meters :offset-assert 60)
|
|
(swim-jump-height-min meters :offset-assert 64)
|
|
(swim-jump-height-max meters :offset-assert 68)
|
|
(tube-jump-height-min meters :offset-assert 72)
|
|
(tube-jump-height-max meters :offset-assert 76)
|
|
(carry-jump-height-min meters :offset-assert 80)
|
|
(carry-jump-height-max meters :offset-assert 84)
|
|
(mech-jump-height-min meters :offset-assert 88)
|
|
(mech-jump-height-max meters :offset-assert 92)
|
|
(mech-carry-jump-height-min meters :offset-assert 96)
|
|
(mech-carry-jump-height-max meters :offset-assert 100)
|
|
(indax-jump-height-min meters :offset-assert 104)
|
|
(indax-jump-height-max meters :offset-assert 108)
|
|
(indax-double-jump-height-min meters :offset-assert 112)
|
|
(indax-double-jump-height-max meters :offset-assert 116)
|
|
(roll-duration uint64 :offset-assert 120)
|
|
(roll-jump-pre-window uint64 :offset-assert 128)
|
|
(roll-jump-post-window uint64 :offset-assert 136)
|
|
(roll-timeout uint64 :offset-assert 144)
|
|
(roll-speed-min meters :offset-assert 152)
|
|
(roll-speed-inc meters :offset-assert 156)
|
|
(roll-flip-duration uint64 :offset-assert 160)
|
|
(roll-flip-height meters :offset-assert 168)
|
|
(roll-flip-dist meters :offset-assert 172)
|
|
(roll-flip-art-height meters :offset-assert 176)
|
|
(roll-flip-art-dist meters :offset-assert 180)
|
|
(duck-slide-distance meters :offset-assert 184)
|
|
(fall-far meters :offset-assert 188)
|
|
(fall-far-inc meters :offset-assert 192)
|
|
(attack-timeout uint64 :offset-assert 200)
|
|
(ground-timeout uint64 :offset-assert 208)
|
|
(slide-down-timeout uint64 :offset-assert 216)
|
|
(fall-timeout uint64 :offset-assert 224)
|
|
(fall-stumble-threshold meters :offset-assert 232)
|
|
(yellow-projectile-speed meters :offset-assert 236)
|
|
(hit-invulnerable-timeout uint64 :offset-assert 240)
|
|
(same-attack-invulnerable-timeout uint64 :offset-assert 248)
|
|
(run-cycle-length float :offset-assert 256)
|
|
(walk-cycle-dist meters :offset-assert 260)
|
|
(walk-up-cycle-dist meters :offset-assert 264)
|
|
(walk-down-cycle-dist meters :offset-assert 268)
|
|
(walk-side-cycle-dist meters :offset-assert 272)
|
|
(run-cycle-dist meters :offset-assert 276)
|
|
(run-up-cycle-dist meters :offset-assert 280)
|
|
(run-down-cycle-dist meters :offset-assert 284)
|
|
(run-side-cycle-dist meters :offset-assert 288)
|
|
(run-wall-cycle-dist meters :offset-assert 292)
|
|
(duck-walk-cycle-dist meters :offset-assert 296)
|
|
(wade-shallow-walk-cycle-dist meters :offset-assert 300)
|
|
(wade-deep-walk-cycle-dist meters :offset-assert 304)
|
|
(mech-walk-cycle-dist meters :offset-assert 308)
|
|
(mech-run-cycle-dist meters :offset-assert 312)
|
|
(smack-surface-dist meters :offset-assert 316)
|
|
(smack-surface-height meters :offset-assert 320)
|
|
(min-dive-depth meters :offset-assert 324)
|
|
(root-radius meters :offset-assert 328)
|
|
(root-offset vector :inline :offset-assert 336)
|
|
(body-radius meters :offset-assert 352)
|
|
(edge-radius meters :offset-assert 356)
|
|
(edge-offset vector :inline :offset-assert 368)
|
|
(edge-grab-height-off-ground meters :offset-assert 384)
|
|
(head-radius meters :offset-assert 388)
|
|
(head-height meters :offset-assert 392)
|
|
(head-offset vector :inline :offset-assert 400)
|
|
(spin-radius meters :offset-assert 416)
|
|
(spin-offset vector :inline :offset-assert 432)
|
|
(duck-spin-radius meters :offset-assert 448)
|
|
(duck-spin-offset vector :inline :offset-assert 464)
|
|
(punch-radius meters :offset-assert 480)
|
|
(punch-offset vector :inline :offset-assert 496)
|
|
(uppercut-radius meters :offset-assert 512)
|
|
(uppercut0-offset vector :inline :offset-assert 528)
|
|
(uppercut1-offset vector :inline :offset-assert 544)
|
|
(flop-radius meters :offset-assert 560)
|
|
(flop0-offset vector :inline :offset-assert 576)
|
|
(flop1-offset vector :inline :offset-assert 592)
|
|
(stuck-time seconds :offset-assert 608)
|
|
(stuck-timeout seconds :offset-assert 616)
|
|
(stuck-distance meters :offset-assert 624)
|
|
(tongue-pull-speed-min float :offset-assert 628)
|
|
(tongue-pull-speed-max float :offset-assert 632)
|
|
(yellow-attack-timeout uint64 :offset-assert 640)
|
|
(fall-height meters :offset-assert 648)
|
|
(mech-jump-thrust-fuel float :offset-assert 652)
|
|
(strafe-jump-pre-window uint64 :offset-assert 656)
|
|
(strafe-jump basic :offset-assert 664)
|
|
(strafe-duck-jump basic :offset-assert 668)
|
|
(dark-jump-height-min meters :offset-assert 672)
|
|
(dark-jump-height-max meters :offset-assert 676)
|
|
(ladder-walk-up-speed meters :offset-assert 680)
|
|
(ladder-walk-down-speed meters :offset-assert 684)
|
|
(ladder-slide-speed meters :offset-assert 688)
|
|
(invisible-duration uint64 :offset-assert 696)
|
|
(mech-walk-carry-cycle-dist meters :offset-assert 704)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c4
|
|
:flag-assert #x9000002c4
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *target-shadow-control* shadow-control) ;; shadow-control
|
|
;; (define-extern *TARGET-bank* target-bank) ;; target-bank
|
|
;; (define-extern target-start-attack function) ;; (function none :behavior target)
|
|
;; (define-extern target-danger-set! function) ;; (function symbol symbol none :behavior target)
|
|
;; (define-extern target-collide-set! function) ;; (function symbol float int :behavior target)
|
|
;; (define-extern target-skel-group function)
|
|
;; (define-extern debounce-speed function) ;; (function float float vector vector float :behavior target)
|
|
;; (define-extern target-align-vel-z-adjust function) ;; (function float float :behavior target)
|
|
;; (define-extern average-turn-angle function) ;; (function target float)
|
|
;; (define-extern can-play-stance-amibent? function) ;; (function symbol :behavior target)
|
|
;; (define-extern target-height-above-ground function) ;; (function float :behavior target)
|
|
;; (define-extern find-collision-below function)
|
|
;; (define-extern can-jump? function) ;; (function symbol symbol :behavior target)
|
|
;; (define-extern target-jump-go function) ;; (function none :behavior target)
|
|
;; (define-extern move-legs? function) ;; (function symbol :behavior target)
|
|
;; (define-extern jump-hit-ground-stuck? function) ;; (function symbol :behavior target)
|
|
;; (define-extern target-time-to-ground function) ;; (function time-frame :behavior target)
|
|
;; (define-extern fall-test function) ;; (function (state symbol target) float none :behavior target)
|
|
;; (define-extern slide-down-test function) ;; (function none :behavior target)
|
|
;; (define-extern smack-surface? function) ;; (function symbol symbol :behavior target)
|
|
;; (define-extern can-roll? function) ;; (function symbol :behavior target)
|
|
;; (define-extern can-duck? function) ;; (function symbol :behavior target)
|
|
;; (define-extern can-exit-duck? function) ;; (function target symbol)
|
|
;; (define-extern can-hands? function) ;; (function symbol symbol :behavior target)
|
|
;; (define-extern can-feet? function) ;; (function symbol symbol :behavior target)
|
|
;; (define-extern are-still? function) ;; (function symbol :behavior target)
|
|
;; (define-extern vector-local+! function) ;; (function vector vector vector :behavior target)
|
|
;; (define-extern move-forward function) ;; (function float vector :behavior target)
|
|
;; (define-extern set-forward-vel function) ;; (function float vector :behavior target)
|
|
;; (define-extern delete-back-vel function) ;; (function none :behavior target)
|
|
;; (define-extern set-side-vel function) ;; (function float vector :behavior target)
|
|
;; (define-extern target-timed-invulnerable function) ;; (function time-frame target int none)
|
|
;; (define-extern target-timed-invulnerable-off function) ;; (function target int none)
|
|
;; (define-extern target-log-attack function) ;; (function attack-info symbol symbol :behavior target)
|
|
;; (define-extern ground-tween-initialize function) ;; (function ground-tween-info uint uint uint uint uint uint float ground-tween-info :behavior target)
|
|
;; (define-extern ground-tween-update function) ;; (function ground-tween-info float float float none :behavior target)
|
|
;; (define-extern target-pos function) ;; (function int vector)
|
|
;; (define-extern target-cam-pos function) ;; (function vector)
|
|
;; (define-extern target-rot function) ;; (function quaternion)
|
|
;; (define-extern external-target-spawn function)
|
|
;; (define-extern target-reset-on-task-finish function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-vu0 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern ocean-vu0-block object) ;; vu-function
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctywide-speech ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern restore-city-speeches function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; combx-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype combx-elevator (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:methods
|
|
(combx-elevator-method-21 () none) ;; 21
|
|
(combx-elevator-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype combx-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern init-mood-combx function)
|
|
;; (define-extern update-mood-combx function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hud-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-string (structure)
|
|
((text string :offset-assert 0) ;; guessed by decompiler
|
|
(scale float :offset-assert 4)
|
|
(color font-color :offset-assert 8) ;; guessed by decompiler
|
|
(flags font-flags :offset-assert 12) ;; guessed by decompiler
|
|
(pos vector4w :inline :offset-assert 16) ;; int32 4
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-sprite (structure)
|
|
((pos vector4w :inline :offset-assert 0)
|
|
(offset-x float :offset-assert 0)
|
|
(offset-y float :offset-assert 4)
|
|
(color vector4w :inline :offset-assert 16)
|
|
(flags uint32 :offset-assert 32)
|
|
(scale-x float :offset-assert 36)
|
|
(scale-y float :offset-assert 40)
|
|
(angle float :offset-assert 44)
|
|
(tex texture :offset-assert 48) ;; guessed by decompiler
|
|
(tid uint32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
(:methods
|
|
(hud-sprite-method-9 () none) ;; 9 ;; (draw (_type_ dma-buffer level) none 9)
|
|
(hud-sprite-method-10 () none) ;; 10 ;; (hud-sprite-method-10 (_type_ dma-buffer level int int int int) object 10)
|
|
(hud-sprite-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-box (structure)
|
|
((box bounding-box2 :inline :offset-assert 0)
|
|
(min vector2 :inline :offset-assert 0)
|
|
(max vector2 :inline :offset-assert 8)
|
|
(color vector4w :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x20
|
|
:flag-assert #xe00000020
|
|
(:methods
|
|
(hud-box-method-9 () none) ;; 9 ;; (draw-box-prim-only (_type_ dma-buffer) none 9)
|
|
(hud-box-method-10 () none) ;; 10 ;; (draw-box-alpha-1 (_type_ dma-buffer) none 10)
|
|
(hud-box-method-11 () none) ;; 11 ;; (draw-box-alpha-2 (_type_ dma-buffer) none 11)
|
|
(hud-box-method-12 () none) ;; 12 ;; (draw-box-alpha-3 (_type_ dma-buffer) none 12)
|
|
(hud-box-method-13 () none) ;; 13 ;; (draw-scan-and-line (_type_ dma-buffer float) int 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-icon (structure)
|
|
((icon (pointer manipy) :offset-assert 0) ;; guessed by decompiler
|
|
(pos vector4w :inline :offset-assert 16) ;; int32 4
|
|
(scale-x float :offset-assert 32)
|
|
(scale-y float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-value (structure)
|
|
((current int32 :offset-assert 0)
|
|
(target int32 :offset-assert 4)
|
|
(flags uint16 :offset-assert 8)
|
|
(inc-unit uint16 :offset-assert 10)
|
|
(inc-time uint16 :offset-assert 12)
|
|
(counter uint16 :offset-assert 14)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud (process)
|
|
((trigger-time uint64 :offset-assert 128) ;; time-frame
|
|
(last-hide-time uint64 :offset-assert 136) ;; time-frame
|
|
(offset float :offset-assert 144)
|
|
(flags hud-flags :offset-assert 148) ;; guessed by decompiler
|
|
(values hud-value 8 :offset-assert 152) ;; guessed by decompiler
|
|
(strings hud-string 14 :offset-assert 288) ;; guessed by decompiler
|
|
(sprites hud-sprite 30 :offset-assert 736) ;; guessed by decompiler
|
|
(icons hud-icon 2 :offset-assert 2656) ;; guessed by decompiler
|
|
(gui-id sound-id :offset-assert 2752) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
(:methods
|
|
(hud-method-14 () none) ;; 14 ;; (hidden? (_type_) symbol 14)
|
|
(hud-method-15 () none) ;; 15 ;; (draw (_type_) none 15)
|
|
(hud-method-16 () none) ;; 16 ;; (update-values (_type_) none 16)
|
|
(hud-method-17 () none) ;; 17 ;; (init-callback (_type_) none 17)
|
|
(hud-method-18 () none) ;; 18 ;; (event-callback (_type_ process int symbol event-message-block) symbol 18)
|
|
(hud-method-19 () none) ;; 19 ;; (hud-method-19 (_type_) none 19)
|
|
(hud-method-20 () none) ;; 20 ;; (hud-method-20 (_type_) none 20)
|
|
(hud-method-21 () none) ;; 21 ;; (hud-method-21 (_type_) none 21)
|
|
(hud-method-22 () none) ;; 22 ;; (hud-method-22 (_type_) none 22)
|
|
(hud-method-23 () none) ;; 23 ;; (hud-method-23 (_type_) none 23)
|
|
(hud-method-24 () none) ;; 24 ;; (check-ready-and-maybe-show (_type_ symbol) symbol 24)
|
|
(hud-method-25 () none) ;; 25 ;; (update-value-callback (_type_ int int) none 25)
|
|
(hud-method-26 () none) ;; 26 ;; (alloc-string-if-needed (_type_ int) none 26)
|
|
)
|
|
(:states
|
|
hud-hidden ;; associated process guessed by decompiler, old: (state hud)
|
|
hud-arriving ;; associated process guessed by decompiler, old: (state hud)
|
|
hud-in ;; associated process guessed by decompiler, old: (state hud)
|
|
hud-leaving ;; associated process guessed by decompiler, old: (state float hud)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-ashelin (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-cargo (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-citizen (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-cpanel (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-dig-clasp (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-gun (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-health (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-helldog (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-lurker (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-map (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-moneybag (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-plasmite (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-dig-button (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-predator (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-heatmeter (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-nest-cocoons (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-neo-spawners (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-desert-lizards (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-fac-manager (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-progress (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-rocketsensor (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-ruffians (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-score (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-sig (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-skill (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-skullgem (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-timer (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-turret (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-for-turret-health (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xaf4
|
|
:flag-assert #x1b0a800af4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-squid (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-gunturret (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-gruntegg (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-crimsonhover (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-metalkor (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-big-score (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-goal (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-miss (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-samos-old (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-lurker-button (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-widow (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-race-final-stats (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-mech-air-tank (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-homing-beacon (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-dark-eco-pickup (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-green-eco-pickup (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-mh-centipede (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-arena-tokens (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-kanga-lizard (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-marauder (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-prebot (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-glider-altitude (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; progress-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype progress-list (basic)
|
|
()
|
|
:method-count-assert 10
|
|
:size-assert #x4
|
|
:flag-assert #xa00000004
|
|
(:methods
|
|
(progress-list-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype progress-list-level (progress-list)
|
|
((act int32 :offset-assert 4)
|
|
(mode basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xc
|
|
:flag-assert #xa0000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype progress-box (structure)
|
|
((aspect4x3 hud-box :inline :offset-assert 0)
|
|
(aspect16x9 hud-box :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype progress (process-drawable)
|
|
((scissor-stack UNKNOWN 8 :offset-assert 208)
|
|
(scissor-count int32 :offset-assert 336)
|
|
(current-options menu-option-list :offset-assert 340) ;; guessed by decompiler
|
|
(menu-transition float :offset-assert 344)
|
|
(option-index int32 :offset-assert 348)
|
|
(current-index int32 :offset-assert 352)
|
|
(want-option-index int32 :offset-assert 356)
|
|
(next-option-index int32 :offset-assert 360)
|
|
(graphic-index int32 :offset-assert 364)
|
|
(selected-option symbol :offset-assert 368) ;; guessed by decompiler
|
|
(current symbol :offset-assert 372) ;; guessed by decompiler
|
|
(next symbol :offset-assert 376) ;; guessed by decompiler
|
|
(ring-angle float :offset-assert 380)
|
|
(ring-want-angle float :offset-assert 384)
|
|
(init-quat quaternion :inline :offset-assert 400)
|
|
(pos-transition float :offset-assert 416)
|
|
(anim-frame float :offset-assert 420)
|
|
(swing float :offset-assert 424)
|
|
(main-menu symbol :offset-assert 428) ;; guessed by decompiler
|
|
(state-array UNKNOWN 8 :offset-assert 432)
|
|
(option-index-stack int32 8 :offset-assert 464) ;; guessed by decompiler
|
|
(state-pos int32 :offset-assert 496)
|
|
(secret-buying basic :offset-assert 500)
|
|
(secret-buy-choice basic :offset-assert 504)
|
|
(scanlines-alpha float :offset-assert 508)
|
|
(start-time uint64 :offset-assert 512)
|
|
(which-slot int32 :offset-assert 520)
|
|
(starting-state basic :offset-assert 524)
|
|
(yes-no-choice basic :offset-assert 528)
|
|
(time-out uint64 :offset-assert 536)
|
|
(last-sound uint64 :offset-assert 544)
|
|
(last-move uint64 :offset-assert 552)
|
|
(center-x-backup int32 :offset-assert 560)
|
|
(center-y-backup int32 :offset-assert 564)
|
|
(flip-horizontal basic :offset-assert 568)
|
|
(flip-vertical basic :offset-assert 572)
|
|
(progressive-scan basic :offset-assert 576)
|
|
(aspect-ratio basic :offset-assert 580)
|
|
(video-mode basic :offset-assert 584)
|
|
(stereo-mode-backup int32 :offset-assert 588)
|
|
(vibrations basic :offset-assert 592)
|
|
(subtitles basic :offset-assert 596)
|
|
(languages UNKNOWN 3 :offset-assert 600)
|
|
(subtitle-language-index int32 :offset-assert 600)
|
|
(language-index int32 :offset-assert 604)
|
|
(audio-language-index int32 :offset-assert 608)
|
|
(current-task-index int32 :offset-assert 612)
|
|
(current-line-index int32 :offset-assert 616)
|
|
(first-closed-line-index int32 :offset-assert 620)
|
|
(extra-text-state int32 :offset-assert 624)
|
|
(current-task uint8 :offset-assert 628)
|
|
(num-open-tasks-found int32 :offset-assert 632)
|
|
(num-closed-tasks-found int32 :offset-assert 636)
|
|
(num-unlocked-secrets int32 :offset-assert 640)
|
|
(total-num-tasks int32 :offset-assert 644)
|
|
(missions-total-spacing float :offset-assert 648)
|
|
(clear-screen basic :offset-assert 652)
|
|
(progress-id uint32 :offset-assert 656)
|
|
(lock-tick-count int32 :offset-assert 660)
|
|
)
|
|
:method-count-assert 54
|
|
:size-assert #x298
|
|
:flag-assert #x3602200298
|
|
(:methods
|
|
(progress-method-20 () none) ;; 20 ;; (come-in () _type_ :state 20)
|
|
(progress-method-21 () none) ;; 21 ;; (idle () _type_ :state 21)
|
|
(progress-method-22 () none) ;; 22 ;; (go-away () _type_ :state 22)
|
|
(progress-method-23 () none) ;; 23 ;; (gone () _type_ :state 23)
|
|
(progress-method-24 () none) ;; 24 ;; (init-defaults (_type_) object 24)
|
|
(progress-method-25 () none) ;; 25 ;; (respond-to-cpad (_type_) none 25)
|
|
(progress-method-26 () none) ;; 26 ;; (gone? (_type_) object 26)
|
|
(progress-method-27 () none) ;; 27 ;; (can-go-back? (_type_) symbol 27)
|
|
(progress-method-28 () none) ;; 28 ;; (get-state-check-card (_type_ symbol) symbol 28)
|
|
(progress-method-29 () none) ;; 29 ;; (push-state (_type_) int 29)
|
|
(progress-method-30 () none) ;; 30 ;; (pop-state (_type_) int 30)
|
|
(progress-method-31 () none) ;; 31 ;; (set-next-state (_type_ symbol int) int 31)
|
|
(progress-method-32 () none) ;; 32 ;; (set-menu-options (_type_ symbol) int 32)
|
|
(progress-method-33 () none) ;; 33
|
|
(progress-method-34 () none) ;; 34
|
|
(progress-method-35 () none) ;; 35
|
|
(progress-method-36 () none) ;; 36
|
|
(progress-method-37 () none) ;; 37
|
|
(progress-method-38 () none) ;; 38
|
|
(progress-method-39 () none) ;; 39
|
|
(progress-method-40 () none) ;; 40
|
|
(progress-method-41 () none) ;; 41
|
|
(progress-method-42 () none) ;; 42
|
|
(progress-method-43 () none) ;; 43
|
|
(progress-method-44 () none) ;; 44
|
|
(progress-method-45 () none) ;; 45
|
|
(progress-method-46 () none) ;; 46
|
|
(progress-method-47 () none) ;; 47
|
|
(progress-method-48 () none) ;; 48
|
|
(progress-method-49 () none) ;; 49
|
|
(progress-method-50 () none) ;; 50
|
|
(progress-method-51 () none) ;; 51
|
|
(progress-method-52 () none) ;; 52
|
|
(progress-method-53 () none) ;; 53
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype progress-work (structure)
|
|
((full-screen progress-box :inline :offset-assert 0)
|
|
(small-screen progress-box :inline :offset-assert 64)
|
|
(header progress-box :inline :offset-assert 128)
|
|
(body progress-box :inline :offset-assert 192)
|
|
(body-footer progress-box :inline :offset-assert 256)
|
|
(footer progress-box :inline :offset-assert 320)
|
|
(sub-header progress-box :inline :offset-assert 384)
|
|
(sub-body progress-box :inline :offset-assert 448)
|
|
(sub-body-footer progress-box :inline :offset-assert 512)
|
|
(highscore-0 progress-box :inline :offset-assert 576)
|
|
(highscore-1 progress-box :inline :offset-assert 640)
|
|
(highscore-body progress-box :inline :offset-assert 704)
|
|
(load-save-0a progress-box :inline :offset-assert 768)
|
|
(load-save-0b progress-box :inline :offset-assert 832)
|
|
(load-save-1a progress-box :inline :offset-assert 896)
|
|
(load-save-1b progress-box :inline :offset-assert 960)
|
|
(load-save-2a progress-box :inline :offset-assert 1024)
|
|
(load-save-2b progress-box :inline :offset-assert 1088)
|
|
(load-save-3a progress-box :inline :offset-assert 1152)
|
|
(load-save-3b progress-box :inline :offset-assert 1216)
|
|
(last-slot-saved int32 :offset-assert 1280)
|
|
(selected-num int32 :offset-assert 1284)
|
|
(secrets-unlocked basic :offset-assert 1288)
|
|
(hero-mode-save basic :offset-assert 1292)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x510
|
|
:flag-assert #x900000510
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype progress-icon-part (structure)
|
|
((offset vector2w :inline :offset-assert 0)
|
|
(tex-id uint32 :offset-assert 8)
|
|
(bucket int32 :offset-assert 12)
|
|
(flags uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype progress-icon-array (array)
|
|
((type basic :offset-assert 0)
|
|
(length int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
(content-type basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x10
|
|
:flag-assert #xa00000010
|
|
(:methods
|
|
(progress-icon-array-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-option (basic)
|
|
((name text-id :offset-assert 4) ;; guessed by decompiler
|
|
(menu-option-type uint32 :offset-assert 8)
|
|
(offset-y float :offset-assert 12)
|
|
(box hud-box 1 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
(:methods
|
|
(menu-option-method-9 () none) ;; 9 ;; (respond-progress (_type_ progress symbol) int 9)
|
|
(menu-option-method-10 () none) ;; 10 ;; (draw-option (_type_ progress font-context int symbol) none 10)
|
|
(menu-option-method-11 () none) ;; 11 ;; (menu-option-method-11 () none 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-slider-option (menu-option)
|
|
((setting-offset uint32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-sound-slider-option (menu-slider-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-picture-slider-option (menu-slider-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-sub-menu-option (menu-option)
|
|
((next-state symbol :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-stereo-mode-sound-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-unlocked-sub-menu-option (menu-sub-menu-option)
|
|
((mask uint64 :offset-assert 56)
|
|
(value int32 :offset-assert 64)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x44
|
|
:flag-assert #xc00000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-save-sub-menu-option (menu-sub-menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-main-menu-option (menu-option)
|
|
((next-state symbol :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-memcard-slot-option (menu-option)
|
|
((sprites hud-sprite 5 :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x190
|
|
:flag-assert #xc00000190
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-loading-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-insufficient-space-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-secrets-insufficient-space-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-hero-mode-message-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-insert-card-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-error-loading-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-error-auto-saving-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-card-removed-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-error-disc-removed-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-error-reading-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-icon-info-option (menu-option)
|
|
((sprites hud-sprite 2 :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #xb0
|
|
:flag-assert #xc000000b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-format-card-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-already-exists-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-create-game-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-video-mode-warning-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-video-mode-ok-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-progressive-mode-warning-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-progressive-mode-ok-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-select-start-option (menu-option)
|
|
((current-index float :offset-assert 48)
|
|
(target-index float :offset-assert 52)
|
|
(selected-index int32 :offset-assert 56)
|
|
(scroll-speed float :offset-assert 60)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x40
|
|
:flag-assert #xc00000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-select-scene-option (menu-option)
|
|
((current-index float :offset-assert 48)
|
|
(target-index float :offset-assert 52)
|
|
(selected-index int32 :offset-assert 56)
|
|
(scroll-speed float :offset-assert 60)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x40
|
|
:flag-assert #xc00000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-bigmap-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype paged-menu-option (menu-option)
|
|
((page-index int32 :offset-assert 48)
|
|
(prev-page-index int32 :offset-assert 52)
|
|
(num-pages int32 :offset-assert 56)
|
|
(slide-dir float :offset-assert 60)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x40
|
|
:flag-assert #xc00000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-missions-option (paged-menu-option)
|
|
((current-index float :offset-assert 64)
|
|
(target-index float :offset-assert 68)
|
|
(scroll-speed float :offset-assert 72)
|
|
(on-screen basic :offset-assert 76)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x50
|
|
:flag-assert #xc00000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype highscore-page-info (structure)
|
|
((text uint32 :offset-assert 0)
|
|
(secret uint64 :offset-assert 8)
|
|
(game-score uint8 :offset-assert 16)
|
|
(icon uint32 :offset-assert 20)
|
|
(icon-scalex float :offset-assert 24)
|
|
(icon-scaley float :offset-assert 28)
|
|
(icon-offsetx float :offset-assert 32)
|
|
(icon-offsety float :offset-assert 36)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x28
|
|
:flag-assert #xd00000028
|
|
(:methods
|
|
(highscore-page-info-method-9 () none) ;; 9
|
|
(highscore-page-info-method-10 () none) ;; 10
|
|
(highscore-page-info-method-11 () none) ;; 11
|
|
(highscore-page-info-method-12 () none) ;; 12
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-highscores-option (menu-option)
|
|
((current-index float :offset-assert 48)
|
|
(target-index float :offset-assert 52)
|
|
(num-pages int32 :offset-assert 56)
|
|
(pages UNKNOWN 16 :offset-assert 60)
|
|
(info basic :offset-assert 124)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x80
|
|
:flag-assert #xd00000080
|
|
(:methods
|
|
(menu-highscores-option-method-12 () none) ;; 12
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype controls-string-info (structure)
|
|
((button uint32 :offset-assert 0)
|
|
(action uint32 :offset-assert 4)
|
|
(feature uint64 :offset-assert 8)
|
|
(secret uint64 :offset-assert 16)
|
|
(vehicle uint64 :offset-assert 24)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x20
|
|
:flag-assert #xa00000020
|
|
(:methods
|
|
(controls-string-info-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype controls-page-info (structure)
|
|
((title uint32 :offset-assert 0)
|
|
(feature uint64 :offset-assert 8)
|
|
(secret uint64 :offset-assert 16)
|
|
(vehicle uint64 :offset-assert 24)
|
|
(current-index float :offset-assert 32)
|
|
(target-index float :offset-assert 36)
|
|
(num-text int32 :offset-assert 40)
|
|
(on-screen basic :offset-assert 44)
|
|
(text UNKNOWN 9 :offset-assert 48)
|
|
(strings basic :offset-assert 84)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x58
|
|
:flag-assert #xc00000058
|
|
(:methods
|
|
(controls-page-info-method-9 () none) ;; 9
|
|
(controls-page-info-method-10 () none) ;; 10
|
|
(controls-page-info-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-controls-option (paged-menu-option)
|
|
((current-index float :offset-assert 64)
|
|
(target-index float :offset-assert 68)
|
|
(pages UNKNOWN 7 :offset-assert 76)
|
|
(info basic :offset-assert 104)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x6c
|
|
:flag-assert #xd0000006c
|
|
(:methods
|
|
(menu-controls-option-method-12 () none) ;; 12
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype secret-item-option (menu-option)
|
|
((cost int32 :offset-assert 48)
|
|
(secret uint64 :offset-assert 56)
|
|
(avail-after uint16 :offset-assert 64) ;; game-task-node
|
|
(required-secrets uint64 :offset-assert 72)
|
|
(mask-secrets uint64 :offset-assert 80)
|
|
(flags uint8 :offset-assert 88)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x59
|
|
:flag-assert #xe00000059
|
|
(:methods
|
|
(secret-item-option-method-12 () none) ;; 12
|
|
(secret-item-option-method-13 () none) ;; 13
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-secret-option (menu-option)
|
|
((current-index float :offset-assert 48)
|
|
(target-index float :offset-assert 52)
|
|
(selected-index int32 :offset-assert 56)
|
|
(buy-menu basic :offset-assert 60)
|
|
(available-title basic :offset-assert 64)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x44
|
|
:flag-assert #xc00000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-option-list (basic)
|
|
((y-center int32 :offset-assert 4)
|
|
(y-space int32 :offset-assert 8)
|
|
(scale float :offset-assert 12)
|
|
(options (array menu-option) :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-qr-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-restart-mission-qr-option (menu-qr-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-quit-qr-option (menu-qr-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-graphic-option (menu-option)
|
|
((setting-offset uint32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-on-off-progressive-scan-graphic-option (menu-graphic-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-aspect-ratio-option (menu-graphic-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-center-screen-graphic-option (menu-graphic-option)
|
|
((next-state symbol :offset-assert 52) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x38
|
|
:flag-assert #xc00000038
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-video-mode-option (menu-graphic-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-camera-option (menu-option)
|
|
((setting-offset uint32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-game-option (menu-option)
|
|
((setting-offset uint32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-language-option (menu-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-on-off-game-vibrations-option (menu-game-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-on-off-game-subtitles-option (menu-game-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-language-game-option (menu-game-option)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x34
|
|
:flag-assert #xc00000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype inventory-item (structure)
|
|
((icon uint32 :offset-assert 0)
|
|
(icon-scale float :offset-assert 4)
|
|
(offset vector2 :offset-assert 16)
|
|
(feature uint64 :offset-assert 24)
|
|
(vehicle uint64 :offset-assert 32)
|
|
(item uint64 :offset-assert 40)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x30
|
|
:flag-assert #xb00000030
|
|
(:methods
|
|
(inventory-item-method-9 () none) ;; 9
|
|
(inventory-item-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype inventory-item-group (structure)
|
|
((name uint32 :offset-assert 0)
|
|
(index-left uint8 :offset-assert 4)
|
|
(index-right uint8 :offset-assert 5)
|
|
(index-up uint8 :offset-assert 6)
|
|
(index-down uint8 :offset-assert 7)
|
|
(items basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #xc
|
|
:flag-assert #xb0000000c
|
|
(:methods
|
|
(inventory-item-group-method-9 () none) ;; 9
|
|
(inventory-item-group-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype inventory-screen (structure)
|
|
((name uint32 :offset-assert 0)
|
|
(current-index uint8 :offset-assert 4)
|
|
(groups basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xc
|
|
:flag-assert #xa0000000c
|
|
(:methods
|
|
(inventory-screen-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype menu-inventory (menu-option)
|
|
((current-index float :offset-assert 48)
|
|
(target-index float :offset-assert 52)
|
|
(screens basic :offset-assert 56)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x3c
|
|
:flag-assert #xc0000003c
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; board-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern board-charge-track function)
|
|
;; (define-extern board-zap-track function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; spatial-hash-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (deftype grid-hash-word (uint8)
|
|
;; ()
|
|
;; :flag-assert #x900000001
|
|
;; )
|
|
|
|
#|
|
|
(deftype grid-hash-box (structure)
|
|
((min int8 3 :offset-assert 0) ;; guessed by decompiler
|
|
(max int8 3 :offset-assert 3) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype grid-hash (basic)
|
|
((work grid-hash-work :offset-assert 4) ;; guessed by decompiler
|
|
(search-box grid-hash-box :inline :offset-assert 8)
|
|
(bucket-size int16 :offset-assert 14)
|
|
(axis-scale float 3 :offset-assert 16) ;; guessed by decompiler
|
|
(dimension-array int8 3 :offset-assert 28) ;; guessed by decompiler
|
|
(vertical-cell-count int8 :offset-assert 31)
|
|
(bucket-array (pointer grid-hash-word) :offset-assert 32) ;; guessed by decompiler
|
|
(box-min float 3 :offset-assert 36) ;; guessed by decompiler
|
|
(box-max float 3 :offset-assert 48) ;; guessed by decompiler
|
|
(object-count int16 :offset-assert 60)
|
|
(bucket-count int16 :offset-assert 62)
|
|
(min-cell-size float :offset-assert 64)
|
|
(bucket-memory-size int32 :offset-assert 68)
|
|
(mem-bucket-array (pointer grid-hash-word) :offset-assert 72) ;; guessed by decompiler
|
|
(spr-bucket-array (pointer grid-hash-word) :offset-assert 76) ;; guessed by decompiler
|
|
(debug-draw symbol :offset-assert 80) ;; guessed by decompiler
|
|
(use-scratch-ram symbol :offset-assert 84) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x58
|
|
:flag-assert #x1900000058
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(grid-hash-method-9 () none) ;; 9 ;; (update-grid-for-objects-in-box (_type_ int vector vector) none 9)
|
|
(grid-hash-method-10 () none) ;; 10 ;; (clear-bucket-array (_type_) none 10)
|
|
(grid-hash-method-11 () none) ;; 11 ;; (setup-search-box (_type_ int vector vector vector) none 11)
|
|
(grid-hash-method-12 () none) ;; 12 ;; (search-for-point (_type_ vector) (pointer uint8) 12)
|
|
(grid-hash-method-13 () none) ;; 13 ;; (search-for-sphere (_type_ vector float) (pointer uint8) 13)
|
|
(grid-hash-method-14 () none) ;; 14 ;; (draw (_type_ rgba) none 14)
|
|
(grid-hash-method-15 () none) ;; 15 ;; (dump-grid-info (_type_) none 15)
|
|
(grid-hash-method-16 () none) ;; 16 ;; (verify-bits-in-bucket (_type_ grid-hash-box grid-hash-box) none 16)
|
|
(grid-hash-method-17 () none) ;; 17 ;; (box-of-everything (_type_ object grid-hash-box) none 17)
|
|
(grid-hash-method-18 () none) ;; 18 ;; (grid-hash-method-18 (_type_ grid-hash-box int) none 18)
|
|
(grid-hash-method-19 () none) ;; 19 ;; (grid-hash-method-19 (_type_ grid-hash-box int) none 19)
|
|
(grid-hash-method-20 () none) ;; 20 ;; (do-search! (_type_ grid-hash-box (pointer uint8)) none 20)
|
|
(grid-hash-method-21 () none) ;; 21 ;; (set-up-box (_type_ grid-hash-box vector vector) none 21)
|
|
(grid-hash-method-22 () none) ;; 22 ;; (sphere-to-grid-box (_type_ grid-hash-box sphere) none 22)
|
|
(grid-hash-method-23 () none) ;; 23 ;; (line-sphere-to-grid-box (_type_ grid-hash-box vector vector float) none 23)
|
|
(grid-hash-method-24 () none) ;; 24 ;; (update-grid (_type_) none 24)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype find-nav-sphere-ids-params (structure)
|
|
((bsphere sphere :inline :offset-assert 0)
|
|
(y-threshold float :offset-assert 16)
|
|
(len int16 :offset-assert 20)
|
|
(max-len int16 :offset-assert 22)
|
|
(mask uint8 :offset-assert 24)
|
|
(array (pointer uint8) :offset-assert 28) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sphere-hash (grid-hash)
|
|
((sphere-array (inline-array sphere) :offset-assert 88) ;; guessed by decompiler
|
|
(max-object-count int16 :offset-assert 92)
|
|
(pad int16 :offset-assert 94)
|
|
(mem-sphere-array uint32 :offset-assert 96)
|
|
(spr-sphere-array uint32 :offset-assert 100)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x68
|
|
:flag-assert #x2100000068
|
|
(:methods
|
|
;; (new (symbol type int int) _type_ 0)
|
|
(sphere-hash-method-25 () none) ;; 25 ;; (clear-objects! (_type_) none 25)
|
|
(sphere-hash-method-26 () none) ;; 26 ;; (add-a-sphere (_type_ vector) int 26)
|
|
(sphere-hash-method-27 () none) ;; 27 ;; (add-a-sphere-with-flag (_type_ vector int) int 27)
|
|
(sphere-hash-method-28 () none) ;; 28 ;; (update-from-spheres (_type_) none 28)
|
|
(sphere-hash-method-29 () none) ;; 29 ;; (sphere-hash-method-29 (_type_ find-nav-sphere-ids-params int int int) none 29)
|
|
(sphere-hash-method-30 () none) ;; 30 ;; (find-nav-sphere-ids (_type_ find-nav-sphere-ids-params) none 30)
|
|
(sphere-hash-method-31 () none) ;; 31 ;; (add-sphere-with-mask-and-id (_type_ vector int int) symbol 31)
|
|
(sphere-hash-method-32 () none) ;; 32 ;; (sphere-hash-method-32 (_type_ vector vector float int) symbol 32)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hash-object-info (structure)
|
|
((object basic :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spatial-hash (sphere-hash)
|
|
((object-array (inline-array hash-object-info) :offset-assert 104) ;; guessed by decompiler
|
|
(mem-object-array (inline-array hash-object-info) :offset-assert 108) ;; guessed by decompiler
|
|
(spr-object-array (inline-array hash-object-info) :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x74
|
|
:flag-assert #x2800000074
|
|
(:methods
|
|
;; (new (symbol type int int) _type_ 0)
|
|
(spatial-hash-method-33 () none) ;; 33
|
|
(spatial-hash-method-34 () none) ;; 34 ;; (add-an-object (_type_ vector hash-object-info) int 34)
|
|
(spatial-hash-method-35 () none) ;; 35 ;; (fill-actor-list-for-box (_type_ bounding-box (pointer collide-shape) int) int 35)
|
|
(spatial-hash-method-36 () none) ;; 36 ;; (fill-actor-list-for-sphere (_type_ sphere (pointer collide-shape) int) int 36)
|
|
(spatial-hash-method-37 () none) ;; 37 ;; (fill-actor-list-for-line-sphere (_type_ vector vector float (pointer collide-shape) int int) int 37)
|
|
(spatial-hash-method-38 () none) ;; 38 ;; (fill-actor-list-for-vec+r (_type_ vector (pointer collide-shape) int) int 38)
|
|
(spatial-hash-method-39 () none) ;; 39 ;; (spatial-hash-method-39 (_type_ object hash-object-info) int 39)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; egg-spider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype egg-spider-shot (metalhead-grenade-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x214
|
|
:flag-assert #x2901a00214
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype egg-spider (nav-enemy)
|
|
((base-height float :offset-assert 620)
|
|
(target-pos vector :inline :offset-assert 624)
|
|
(offset-target-pos vector :inline :offset-assert 640)
|
|
(change-dir-time uint64 :offset-assert 656)
|
|
(last-change-dir uint64 :offset-assert 664)
|
|
(onscreen-time uint64 :offset-assert 672)
|
|
(next-explosion uint64 :offset-assert 680)
|
|
(move-angle float :offset-assert 688)
|
|
(heading basic :offset-assert 692)
|
|
(size float :offset-assert 696)
|
|
(angle-spot float :offset-assert 700)
|
|
(trackable? basic :offset-assert 704)
|
|
(vehicle-attack? basic :offset-assert 708)
|
|
(seat-index int32 :offset-assert 712)
|
|
(wvehicle uint64 :offset-assert 720)
|
|
(vec-up vector :inline :offset-assert 736)
|
|
(vec-up-speed vector :inline :offset-assert 752)
|
|
(traj trajectory :inline :offset-assert 768)
|
|
(init-pos vector :inline :offset-assert 816)
|
|
(jump-pos float :offset-assert 832)
|
|
)
|
|
:method-count-assert 197
|
|
:size-assert #x344
|
|
:flag-assert #xc502d00344
|
|
(:methods
|
|
(egg-spider-method-190 () none) ;; 190
|
|
(egg-spider-method-194 () none) ;; 194
|
|
(egg-spider-method-195 () none) ;; 195
|
|
(egg-spider-method-196 () none) ;; 196
|
|
)
|
|
(:state-methods
|
|
idle ;; 33
|
|
jump-on-vehicle ;; 193
|
|
attack ;; 191
|
|
knocked ;; 31
|
|
ambush ;; 47
|
|
on-vehicle ;; 192
|
|
hostile ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spider-manager (process-drawable)
|
|
((count-alive int32 :offset-assert 196)
|
|
(next-spawn-time uint64 :offset-assert 204)
|
|
(min-spawn-delay int32 :offset-assert 212)
|
|
(max-spawn-delay int32 :offset-assert 216)
|
|
(next-spot-time uint64 :offset-assert 220)
|
|
(min-spot-delay int32 :offset-assert 228)
|
|
(max-spot-delay int32 :offset-assert 232)
|
|
(actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(spawn-pos vector :inline :offset-assert 252)
|
|
(nav-id uint32 :offset-assert 268)
|
|
(can-rid uint64 :offset-assert 276)
|
|
(next-explosion uint64 :offset-assert 284)
|
|
(num-nav-mesh int32 :offset-assert 292)
|
|
(count-max int32 :offset-assert 296)
|
|
(max-spawn-size float :offset-assert 300)
|
|
(count-death uint32 :offset-assert 304)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x138
|
|
:flag-assert #x1a00c00138
|
|
(:methods
|
|
(spider-manager-method-21 () none) ;; 21
|
|
(spider-manager-method-22 () none) ;; 22
|
|
(spider-manager-method-23 () none) ;; 23
|
|
(spider-manager-method-24 () none) ;; 24
|
|
(spider-manager-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *egg-spider-always-trackable?* object)
|
|
;; (define-extern check-drop-level-egg-spider-dirt-rubble function)
|
|
;; (define-extern spt-birth-func-brightness-egg-spider function)
|
|
;; (define-extern spt-birth-func-part-egg-spider-clumps function)
|
|
;; (define-extern spt-func-part-egg-spider-clumps function)
|
|
;; (define-extern spt-birth-func-part-egg-spider-clumps-mass function)
|
|
;; (define-extern spt-func-part-egg-spider-clumps-mass function)
|
|
;; (define-extern spt-birth-func-part-egg-spider-clumps-pop function)
|
|
;; (define-extern spt-func-part-egg-spider-clumps-pop function)
|
|
;; (define-extern spt-birth-func-part-egg-spider-clumps-stays function)
|
|
;; (define-extern spt-func-part-egg-spider-clumps-stays function)
|
|
;; (define-extern *egg-spider-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern *egg-spider-next-knocked-vehicle* object)
|
|
;; (define-extern egg-spider-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; actor-hash-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *actor-list* object) ;; (pointer collide-shape)
|
|
;; (define-extern *actor-list-length* object) ;; int
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; texture-anim-funcs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern noise-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern cloud-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern cloud-texture-anim-func function) ;; (function dma-buffer texture-anim int)
|
|
;; (define-extern fog-texture-anim-init function) ;; (function texture-anim int)
|
|
;; (define-extern *fog-texture-work* object) ;; fog-texture-work
|
|
;; (define-extern real-fog-texture-anim-func function) ;; (function dma-buffer texture-anim int)
|
|
;; (define-extern fog-texture-anim-func function) ;; (function dma-buffer texture-anim int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sprite-glow ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sprite-glow-template (structure)
|
|
((clear-init-giftag gs-gif-tag :inline :offset-assert 0)
|
|
(clear-init-adcmds gs-adcmd 5 :offset-assert 16) ;; guessed by decompiler
|
|
(clear-draw-giftag gs-gif-tag :inline :offset-assert 96)
|
|
(clear-draw-clr-0 gs-packed-rgba :inline :offset-assert 112)
|
|
(clear-draw-xyz-0 gs-packed-xyzw 2 :offset-assert 128) ;; guessed by decompiler
|
|
(clear-draw-clr-1 gs-packed-rgba :inline :offset-assert 160)
|
|
(clear-draw-xyz-1 vector 2 :offset-assert 176) ;; guessed by decompiler
|
|
(offscr-setup-giftag gs-gif-tag :inline :offset-assert 208)
|
|
(offscr-setup-adcmds gs-adcmd 8 :offset-assert 224) ;; guessed by decompiler
|
|
(offscr-first-giftag gs-gif-tag :inline :offset-assert 352)
|
|
(offscr-first-clr gs-packed-rgba :inline :offset-assert 368)
|
|
(offscr-first-uv-0 gs-packed-uv :inline :offset-assert 384)
|
|
(offscr-first-xyzw-0 gs-packed-xyzw :inline :offset-assert 400)
|
|
(offscr-first-uv-1 gs-packed-uv :inline :offset-assert 416)
|
|
(offscr-first-xyzw-1 gs-packed-xyzw :inline :offset-assert 432)
|
|
(repeat-draw-giftag gs-gif-tag :inline :offset-assert 448)
|
|
(repeat-draw-adcmds gs-adcmd 29 :offset-assert 464) ;; guessed by decompiler
|
|
(flare-alpha-giftag gs-gif-tag :inline :offset-assert 928)
|
|
(flare-alpha-clr gs-packed-rgba :inline :offset-assert 944)
|
|
(flare-alpha-uv gs-packed-uv :inline :offset-assert 960)
|
|
(flare-alpha-xyzw-0 gs-packed-xyzw :inline :offset-assert 976)
|
|
(flare-alpha-xyzw-1 gs-packed-xyzw :inline :offset-assert 992)
|
|
(flare-alpha-xyzw-2 gs-packed-xyzw :inline :offset-assert 1008)
|
|
(flare-alpha-xyzw-3 gs-packed-xyzw :inline :offset-assert 1024)
|
|
(flare-init-giftag gs-gif-tag :inline :offset-assert 1040)
|
|
(flare-init-adcmds gs-adcmd 8 :offset-assert 1056) ;; guessed by decompiler
|
|
(flare-draw-giftag gs-gif-tag :inline :offset-assert 1184)
|
|
(flare-draw-clr gs-packed-rgba :inline :offset-assert 1200)
|
|
(flare-draw-stq-0 gs-packed-stq :inline :offset-assert 1216)
|
|
(flare-draw-xyzw-0 gs-packed-xyzw :inline :offset-assert 1232)
|
|
(flare-draw-stq-1 gs-packed-stq :inline :offset-assert 1248)
|
|
(flare-draw-xyzw-1 gs-packed-xyzw :inline :offset-assert 1264)
|
|
(flare-draw-stq-2 gs-packed-stq :inline :offset-assert 1280)
|
|
(flare-draw-xyzw-2 gs-packed-xyzw :inline :offset-assert 1296)
|
|
(flare-draw-stq-3 gs-packed-stq :inline :offset-assert 1312)
|
|
(flare-draw-xyzw-3 gs-packed-xyzw :inline :offset-assert 1328)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x540
|
|
:flag-assert #x900000540
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-glow-consts (structure)
|
|
((camera matrix :inline :offset-assert 0)
|
|
(perspective matrix :inline :offset-assert 64)
|
|
(hvdf-offset vector :inline :offset-assert 128)
|
|
(hmge-scale vector :inline :offset-assert 144)
|
|
(consts vector :inline :offset-assert 160)
|
|
(pfog0 float :offset-assert 160)
|
|
(deg-to-rad float :offset-assert 164)
|
|
(min-scale float :offset-assert 168)
|
|
(inv-area float :offset-assert 172)
|
|
(sincos-01 vector :inline :offset-assert 176)
|
|
(sincos-23 vector :inline :offset-assert 192)
|
|
(sincos-45 vector :inline :offset-assert 208)
|
|
(sincos-67 vector :inline :offset-assert 224)
|
|
(sincos-89 vector :inline :offset-assert 240)
|
|
(basis-x vector :inline :offset-assert 256)
|
|
(basis-y vector :inline :offset-assert 272)
|
|
(xy-array vector 4 :offset-assert 288) ;; guessed by decompiler
|
|
(clamp-min vector :inline :offset-assert 352)
|
|
(clamp-max vector :inline :offset-assert 368)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x180
|
|
:flag-assert #x900000180
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-glow-dma-packet-data (structure)
|
|
((control-packet dma-packet :inline :offset-assert 0)
|
|
(vecdata-packet dma-packet :inline :offset-assert 16)
|
|
(shader-cnt-packet dma-packet :inline :offset-assert 32)
|
|
(shader-ref-packet dma-packet :inline :offset-assert 48)
|
|
(mscal-packet dma-packet :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-glow-cnt-template (structure)
|
|
((control-packet dma-packet :inline :offset-assert 0)
|
|
(num-sprites uint32 :offset-assert 16)
|
|
(dummys uint32 3 :offset-assert 20) ;; guessed by decompiler
|
|
(vecdata-packet dma-packet :inline :offset-assert 32)
|
|
(vecdata sprite-glow-data :inline :offset-assert 48)
|
|
(shader-packet dma-packet :inline :offset-assert 112)
|
|
(shader adgif-shader :inline :offset-assert 128)
|
|
(mscal-packet dma-packet :inline :offset-assert 208)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xe0
|
|
:flag-assert #x9000000e0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-glow-ref-template (structure)
|
|
((control-packet dma-packet :inline :offset-assert 0)
|
|
(num-sprites uint32 :offset-assert 16)
|
|
(dummys uint32 3 :offset-assert 20) ;; guessed by decompiler
|
|
(vecdata-packet dma-packet :inline :offset-assert 32)
|
|
(vecdata sprite-glow-data :inline :offset-assert 48)
|
|
(shader-packet dma-packet :inline :offset-assert 112)
|
|
(mscal-packet dma-packet :inline :offset-assert 128)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *sprite-glow-template* object) ;; sprite-glow-template
|
|
;; (define-extern sprite-glow-vu1-block object) ;; vu-function
|
|
;; (define-extern sprite-glow-init-consts function) ;; (function sprite-glow-consts none)
|
|
;; (define-extern sprite-glow-init-engine function) ;; (function dma-buffer none)
|
|
;; (define-extern *sprite-glow-dma-packet-data* object) ;; sprite-glow-dma-packet-data
|
|
;; (define-extern sprite-glow-add-sprite function) ;; (function dma-buffer sprite-vec-data-2d float float float adgif-shader none)
|
|
;; (define-extern sprite-glow-add-simple-sprite function) ;; (function dma-buffer sprite-glow-dma-packet-data sprite-glow-data pointer none)
|
|
;; (define-extern sprite-glow-draw function) ;; (function dma-buffer none)
|
|
;; (define-extern add-shader-to-dma function) ;; (function dma-buffer adgif-shader)
|
|
;; (define-extern *simple-sprite-system* object) ;; simple-sprite-system
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rigid-body-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rigid-body-info (structure)
|
|
((mass float :offset-assert 0)
|
|
(inv-mass float :offset-assert 4)
|
|
(linear-damping float :offset-assert 8)
|
|
(angular-damping float :offset-assert 12)
|
|
(bounce-factor float :offset-assert 16)
|
|
(friction-factor float :offset-assert 20)
|
|
(bounce-mult-factor float :offset-assert 24)
|
|
(cm-offset-joint vector :inline :offset-assert 32)
|
|
(inv-inertial-tensor matrix :inline :offset-assert 48)
|
|
(inertial-tensor matrix :inline :offset-assert 112)
|
|
(inertial-tensor-box meters 3 :offset-assert 176) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xbc
|
|
:flag-assert #xa000000bc
|
|
(:methods
|
|
(rigid-body-info-method-9 () none) ;; 9 ;; (rigid-body-info-method-9 (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-object-extra-info (structure)
|
|
((max-time-step float :offset-assert 0)
|
|
(gravity meters :offset-assert 4)
|
|
(idle-distance meters :offset-assert 8)
|
|
(attack-force-scale float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-object-constants (structure)
|
|
((info rigid-body-info :inline :offset-assert 0)
|
|
(mass float :offset-assert 0)
|
|
(inv-mass float :offset-assert 4)
|
|
(cm-joint-x meters :offset-assert 32)
|
|
(cm-joint-y meters :offset-assert 36)
|
|
(cm-joint-z meters :offset-assert 40)
|
|
(linear-damping float :offset-assert 8)
|
|
(angular-damping float :offset-assert 12)
|
|
(bounce-factor float :offset-assert 16)
|
|
(friction-factor float :offset-assert 20)
|
|
(inertial-tensor-x meters :offset-assert 176)
|
|
(inertial-tensor-y meters :offset-assert 180)
|
|
(inertial-tensor-z meters :offset-assert 184)
|
|
(extra rigid-body-object-extra-info :inline :offset-assert 188)
|
|
(max-time-step float :offset-assert 188)
|
|
(gravity meters :offset-assert 192)
|
|
(idle-distance meters :offset-assert 196)
|
|
(attack-force-scale float :offset-assert 200)
|
|
(name symbol :offset-assert 204) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xd0
|
|
:flag-assert #x9000000d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-impact (structure)
|
|
((point vector :inline :offset-assert 0)
|
|
(normal vector :inline :offset-assert 16)
|
|
(velocity vector :inline :offset-assert 32)
|
|
(impulse float :offset-assert 48)
|
|
(pat pat-surface :offset-assert 52) ;; guessed by decompiler
|
|
(process basic :offset-assert 56)
|
|
(prim-id uint32 :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-control (basic)
|
|
((flags rigid-body-flag :offset-assert 4)
|
|
(info rigid-body-info :offset-assert 8)
|
|
(force-callback basic :offset-assert 12)
|
|
(process process :offset-assert 16) ;; guessed by decompiler
|
|
(blocked-by basic :offset-assert 20)
|
|
(time-remaining float :offset-assert 24)
|
|
(step-count int16 :offset-assert 28)
|
|
(linear-damping float :offset-assert 32)
|
|
(angular-damping float :offset-assert 36)
|
|
(bounce-factor float :offset-assert 40)
|
|
(friction-factor float :offset-assert 44)
|
|
(position vector :inline :offset-assert 48)
|
|
(rot vector :inline :offset-assert 64)
|
|
(rotation quaternion :inline :offset-assert 64)
|
|
(lin-momentum vector :inline :offset-assert 80)
|
|
(ang-momentum vector :inline :offset-assert 96)
|
|
(force vector :inline :offset-assert 112)
|
|
(torque vector :inline :offset-assert 128)
|
|
(lin-velocity vector :inline :offset-assert 144)
|
|
(ang-velocity vector :inline :offset-assert 160)
|
|
(matrix matrix :inline :offset-assert 176)
|
|
(inv-i-world matrix :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x130
|
|
:flag-assert #x2200000130
|
|
(:methods
|
|
;; (new (symbol type process) _type_ 0)
|
|
(rigid-body-control-method-9 () none) ;; 9 ;; (rigid-body-control-method-9 (_type_ collide-shape-moving float) none 9)
|
|
(rigid-body-control-method-10 () none) ;; 10 ;; (rigid-body-control-method-10 (_type_ rigid-body-object float float) object 10)
|
|
(rigid-body-control-method-11 () none) ;; 11 ;; (rigid-body-control-method-11 (_type_ collide-shape-moving) none 11)
|
|
(rigid-body-control-method-12 () none) ;; 12 ;; (rigid-body-control-method-12 (_type_ float) none 12)
|
|
(rigid-body-control-method-13 () none) ;; 13 ;; (rigid-body-control-method-13 (_type_) none 13)
|
|
(rigid-body-control-method-14 () none) ;; 14 ;; (rigid-body-control-method-14 (_type_ float) none 14)
|
|
(rigid-body-control-method-15 () none) ;; 15 ;; (clear-force-torque! (_type_) none 15)
|
|
(rigid-body-control-method-16 () none) ;; 16 ;; (clear-momentum! (_type_) none 16)
|
|
(rigid-body-control-method-17 () none) ;; 17 ;; (rigid-body-control-method-17 (_type_ vector vector) none 17)
|
|
(rigid-body-control-method-18 () none) ;; 18 ;; (rigid-body-control-method-18 (_type_ vector vector) none 18)
|
|
(rigid-body-control-method-19 () none) ;; 19 ;; (rigid-body-control-method-19 (_type_ vector) none 19)
|
|
(rigid-body-control-method-20 () none) ;; 20 ;; (rigid-body-control-method-20 (_type_ vector vector float) none 20)
|
|
(rigid-body-control-method-21 () none) ;; 21 ;; (rigid-body-control-method-21 (_type_ vector vector) vector 21)
|
|
(rigid-body-control-method-22 () none) ;; 22 ;; (rigid-body-control-method-22 (_type_ vector) vector 22)
|
|
(rigid-body-control-method-23 () none) ;; 23 ;; (rigid-body-control-method-23 (_type_) none 23)
|
|
(rigid-body-control-method-24 () none) ;; 24 ;; (rigid-body-control-method-24 (_type_ rigid-body-info vector quaternion basic) none 24)
|
|
(rigid-body-control-method-25 () none) ;; 25 ;; (rigid-body-control-method-25 (_type_ vector quaternion) none 25)
|
|
(rigid-body-control-method-26 () none) ;; 26
|
|
(rigid-body-control-method-27 () none) ;; 27
|
|
(rigid-body-control-method-28 () none) ;; 28
|
|
(rigid-body-control-method-29 () none) ;; 29
|
|
(rigid-body-control-method-30 () none) ;; 30
|
|
(rigid-body-control-method-31 () none) ;; 31
|
|
(rigid-body-control-method-32 () none) ;; 32
|
|
(rigid-body-control-method-33 () none) ;; 33
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-object (process-focusable)
|
|
((info rigid-body-object-constants :offset-assert 208)
|
|
(flags rigid-body-object-flag :offset-assert 216)
|
|
(max-time-step float :offset-assert 224)
|
|
(incoming-attack-id uint32 :offset-assert 228)
|
|
(player-touch-time uint64 :offset-assert 232) ;; time-frame
|
|
(disturbed-time uint64 :offset-assert 240) ;; time-frame
|
|
(player-force-position vector :inline :offset-assert 256)
|
|
(player-force vector :inline :offset-assert 272)
|
|
)
|
|
:method-count-assert 56
|
|
:size-assert #x120
|
|
:flag-assert #x3800a00120
|
|
;; field rigid-body-object-flag is likely a value type.
|
|
(:methods
|
|
(rigid-body-object-method-28 () none) ;; 28 ;; (active () _type_ :state 28)
|
|
(rigid-body-object-method-29 () none) ;; 29 ;; (rigid-body-object-method-29 (_type_ float) none 29)
|
|
(rigid-body-object-method-30 () none) ;; 30 ;; (rigid-body-object-method-30 (_type_) none 30)
|
|
(rigid-body-object-method-31 () none) ;; 31 ;; (alloc-and-init-rigid-body-control (_type_ rigid-body-object-constants) none 31)
|
|
(rigid-body-object-method-32 () none) ;; 32 ;; (allocate-and-init-cshape (_type_) none 32)
|
|
(rigid-body-object-method-33 () none) ;; 33 ;; (init-skel-and-rigid-body (_type_) none 33)
|
|
(rigid-body-object-method-34 () none) ;; 34 ;; (rigid-body-object-method-34 (_type_) none 34)
|
|
(rigid-body-object-method-35 () none) ;; 35 ;; (rigid-body-object-method-35 (_type_) none 35)
|
|
(rigid-body-object-method-36 () none) ;; 36 ;; (do-engine-sounds (_type_) none 36)
|
|
(rigid-body-object-method-37 () none) ;; 37 ;; (rigid-body-object-method-37 (_type_) none 37)
|
|
(rigid-body-object-method-38 () none) ;; 38 ;; (rigid-body-object-method-38 (_type_) none 38)
|
|
(rigid-body-object-method-39 () none) ;; 39 ;; (rigid-body-object-method-39 (_type_) none 39)
|
|
(rigid-body-object-method-40 () none) ;; 40 ;; (rigid-body-object-method-40 (_type_) none 40)
|
|
(rigid-body-object-method-41 () none) ;; 41 ;; (rigid-body-object-method-41 (_type_) none 41)
|
|
(rigid-body-object-method-42 () none) ;; 42 ;; (rigid-body-object-method-42 (_type_) none 42)
|
|
(rigid-body-object-method-43 () none) ;; 43 ;; (rigid-body-object-method-43 (_type_) none 43)
|
|
(rigid-body-object-method-44 () none) ;; 44 ;; (apply-damage (_type_ float rigid-body-impact) none 44)
|
|
(rigid-body-object-method-45 () none) ;; 45 ;; (rigid-body-object-method-45 (_type_ rigid-body-impact) none 45)
|
|
(rigid-body-object-method-46 () none) ;; 46 ;; (rigid-body-object-method-46 (_type_ process-drawable int symbol event-message-block) object 46)
|
|
(rigid-body-object-method-47 () none) ;; 47 ;; (rigid-body-object-method-47 (_type_ process-drawable attack-info touching-shapes-entry penetrate) symbol 47)
|
|
(rigid-body-object-method-48 () none) ;; 48 ;; (rigid-body-object-method-48 (_type_ process-focusable touching-shapes-entry) symbol 48)
|
|
(rigid-body-object-method-49 () none) ;; 49 ;; (rigid-body-object-method-49 (_type_ rigid-body-impact touching-shapes-entry) none 49)
|
|
(rigid-body-object-method-50 () none) ;; 50 ;; (rigid-body-object-method-50 (_type_ float) none 50)
|
|
(rigid-body-object-method-51 () none) ;; 51 ;; (rigid-body-object-method-51 (_type_) none 51)
|
|
(rigid-body-object-method-52 () none) ;; 52 ;; (rigid-body-object-method-52 (_type_) none 52)
|
|
(rigid-body-object-method-53 () none) ;; 53
|
|
(rigid-body-object-method-54 () none) ;; 54
|
|
(rigid-body-object-method-55 () none) ;; 55
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-queue (structure)
|
|
((count int8 :offset-assert 0)
|
|
(manager uint64 :offset-assert 8)
|
|
(array handle 128 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x410
|
|
:flag-assert #x1100000410
|
|
(:methods
|
|
(rigid-body-queue-method-9 () none) ;; 9 ;; (rigid-body-queue-method-9 (_type_) none 9)
|
|
(rigid-body-queue-method-10 () none) ;; 10 ;; (rigid-body-queue-method-10 (_type_) none 10)
|
|
(rigid-body-queue-method-11 () none) ;; 11 ;; (rigid-body-queue-method-11 (_type_ rigid-body-object) none 11)
|
|
(rigid-body-queue-method-12 () none) ;; 12 ;; (rigid-body-queue-method-12 (_type_ int int) none 12)
|
|
(rigid-body-queue-method-13 () none) ;; 13 ;; (rigid-body-queue-method-13 (_type_ int rigid-body-object) none 13)
|
|
(rigid-body-queue-method-14 () none) ;; 14 ;; (rigid-body-queue-method-14 (_type_ int) none 14)
|
|
(rigid-body-queue-method-15 () none) ;; 15 ;; (rigid-body-queue-method-15 (_type_ rigid-body-object) none 15)
|
|
(rigid-body-queue-method-16 () none) ;; 16 ;; (validate (_type_) symbol 16)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ramdisk ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ramdisk-rpc-fill (structure)
|
|
((rsvd1 int32 :offset-assert 0)
|
|
(ee-id int32 :offset-assert 4)
|
|
(rsvd2 int32 2 :offset-assert 8) ;; guessed by decompiler
|
|
(filename uint128 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ramdisk-rpc-load (structure)
|
|
((rsvd int32 :offset-assert 0)
|
|
(ee-id int32 :offset-assert 4)
|
|
(offset uint32 :offset-assert 8)
|
|
(length uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ramdisk-rpc-load-to-ee (structure)
|
|
((rsvd int32 :offset-assert 0)
|
|
(addr int32 :offset-assert 4)
|
|
(offset int32 :offset-assert 8)
|
|
(length int32 :offset-assert 12)
|
|
(filename uint128 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ramdisk-rpc* object) ;; rpc-buffer-pair
|
|
;; (define-extern *current-ramdisk-id* object) ;; int
|
|
;; (define-extern ramdisk-load function) ;; (function int uint uint pointer int)
|
|
;; (define-extern ramdisk-sync function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gsound ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype engine-sound-pers (engine-pers)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x20
|
|
:flag-assert #xf00000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-iop-info (structure)
|
|
((frame uint32 :offset-assert 0)
|
|
(strpos int32 :offset-assert 4)
|
|
(str-id uint32 :offset-assert 8)
|
|
(str-id-sign int32 :offset-assert 8)
|
|
(freemem uint32 :offset-assert 12)
|
|
(chinfo uint8 48 :offset-assert 16) ;; guessed by decompiler
|
|
(freemem2 uint32 :offset-assert 64)
|
|
(nocd uint32 :offset-assert 68)
|
|
(dirtycd uint32 :offset-assert 72)
|
|
(diskspeed uint32 2 :offset-assert 76) ;; guessed by decompiler
|
|
(lastspeed uint32 :offset-assert 84)
|
|
(dupseg int32 :offset-assert 88)
|
|
(times int32 41 :offset-assert 92) ;; guessed by decompiler
|
|
(times-seq uint32 :offset-assert 256)
|
|
(iop-ticks uint32 :offset-assert 260)
|
|
(stream-position uint32 4 :offset-assert 272) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(stream-status stream-status 4 :offset-assert 288) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(stream-name sound-stream-name 4 :offset-assert 304) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(stream-id sound-id 4 :offset-assert 496) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(music-register uint8 17 :offset-assert 512) ;; guessed by decompiler
|
|
(music-excite int8 :offset-assert 528)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2d0
|
|
:flag-assert #x9000002d0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *sound-loop-engine* object) ;; engine-sound-pers
|
|
;; (define-extern *sound-player-rpc* object) ;; rpc-buffer-pair
|
|
;; (define-extern *sound-loader-rpc* object) ;; rpc-buffer-pair
|
|
;; (define-extern sound-name= function) ;; (function sound-name sound-name symbol)
|
|
;; (define-extern *sound-iop-info* object) ;; sound-iop-info
|
|
;; (define-extern str-is-playing? function) ;; (function symbol)
|
|
;; (define-extern str-id-is-playing? function) ;; (function int symbol)
|
|
;; (define-extern current-str-pos function) ;; (function sound-id int)
|
|
;; (define-extern current-str-status function)
|
|
;; (define-extern is-ramdisk-loaded? function) ;; (function symbol symbol)
|
|
;; (define-extern is-cd-in? function) ;; (function symbol)
|
|
;; (define-extern new-sound-id function) ;; (function sound-id)
|
|
;; (define-extern check-irx-version function) ;; (function int)
|
|
;; (define-extern sound-bank-iop-store function) ;; (function sound-name sound-id)
|
|
;; (define-extern sound-bank-iop-free function) ;; (function sound-name sound-id)
|
|
;; (define-extern sound-bank-load function) ;; (function sound-name sound-id)
|
|
;; (define-extern sound-bank-load-from-iop function) ;; (function sound-name sound-id)
|
|
;; (define-extern sound-bank-load-from-ee function) ;; (function sound-name pointer sound-id)
|
|
;; (define-extern sound-bank-unload function) ;; (function sound-name int)
|
|
;; (define-extern sound-music-load function) ;; (function sound-name int)
|
|
;; (define-extern sound-music-unload function) ;; (function int)
|
|
;; (define-extern set-language function) ;; (function language-enum int)
|
|
;; (define-extern sound-set-stereo-mode function) ;; (function stereo-mode none)
|
|
;; (define-extern list-sounds function) ;; (function none)
|
|
;; (define-extern sound-command->string function) ;; (function sound-command string)
|
|
;; (define-extern sound-buffer-dump function) ;; (function int)
|
|
;; (define-extern *sound-player-enable* object) ;; symbol
|
|
;; (define-extern swap-sound-buffers function) ;; (function vector vector vector float int)
|
|
;; (define-extern get-sound-buffer-entry function) ;; (function pointer)
|
|
;; (define-extern free-last-sound-buffer-entry function) ;; (function none)
|
|
;; (define-extern sound-basic-cb function) ;; (function int (pointer int32) none)
|
|
;; (define-extern sound-trans-convert function) ;; (function vector3w vector int)
|
|
;; (define-extern sound-unit-vector-convert function)
|
|
;; (define-extern sound-angle-convert function) ;; (function float int)
|
|
;; (define-extern string->sound-name function) ;; (function string sound-name)
|
|
;; (define-extern sound-name->string function)
|
|
;; (define-extern sound-set-volume function) ;; (function sound-group float int)
|
|
;; (define-extern sound-set-reverb function) ;; (function int float float uint int)
|
|
;; (define-extern sound-set-ear-trans function) ;; (function vector vector vector float int)
|
|
;; (define-extern sound-play-by-name function) ;; (function sound-name sound-id int int int sound-group object sound-id :behavior process-drawable)
|
|
;; (define-extern sound-play-by-spec function) ;; (function sound-spec sound-id vector sound-id :behavior process-drawable)
|
|
;; (define-extern sound-pause function) ;; (function sound-id int)
|
|
;; (define-extern sound-stop function) ;; (function sound-id int)
|
|
;; (define-extern sound-continue function) ;; (function sound-id int)
|
|
;; (define-extern sound-group-pause function) ;; (function sound-group int)
|
|
;; (define-extern sound-group-stop function) ;; (function sound-group int)
|
|
;; (define-extern sound-group-continue function) ;; (function sound-group int)
|
|
;; (define-extern sound-set-flava function) ;; (function uint uint int)
|
|
;; (define-extern sound-set-midi-reg function) ;; (function int int int)
|
|
;; (define-extern sound-set-fps function) ;; (function int int)
|
|
;; (define-extern sound-volume-off function) ;; (function int)
|
|
;; (define-extern *ambient-spec* sound-spec) ;; sound-spec
|
|
;; (define-extern show-iop-info function) ;; (function dma-buffer int)
|
|
;; (define-extern show-iop-memory function) ;; (function dma-buffer int)
|
|
;; (define-extern ear-trans function) ;; (function int vector)
|
|
;; (define-extern make-sqrt-table function) ;; (function int)
|
|
;; (define-extern loader-test-command function) ;; (function sound-command uint none)
|
|
;; (define-extern doppler-pitch-shift function) ;; (function vector vector float)
|
|
;; (define-extern sound-bank-reload function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precura-obs2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mechblock (process-focusable)
|
|
((origin vector :inline :offset-assert 208)
|
|
(drop-point vector :inline :offset-assert 256)
|
|
(allow-drag? symbol :offset-assert 272) ;; guessed by decompiler
|
|
(reset-on-land? symbol :offset-assert 276) ;; guessed by decompiler
|
|
(nav-mesh basic :offset-assert 280)
|
|
(hit-something? symbol :offset-assert 284) ;; guessed by decompiler
|
|
(attack-id uint32 :offset-assert 288)
|
|
(next-entity entity :offset-assert 292) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x128
|
|
:flag-assert #x2200b00128
|
|
(:methods
|
|
(mechblock-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
wait ;; 32
|
|
carry ;; 29
|
|
drag-object ;; 30
|
|
fall ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-bomb (mechblock)
|
|
((bomb-timer uint32 :offset-assert 296)
|
|
(blink-timer uint32 :offset-assert 300)
|
|
(blink-rate float :offset-assert 304)
|
|
(blink basic :offset-assert 308)
|
|
(collide-timer uint32 :offset-assert 312)
|
|
(spin-quat quaternion :inline :offset-assert 320)
|
|
(default-emissive-color vector :inline :offset-assert 336)
|
|
(hint? basic :offset-assert 352)
|
|
(sound-id uint32 :offset-assert 356)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x168
|
|
:flag-assert #x2700f00168
|
|
(:methods
|
|
(precur-bomb-method-38 () none) ;; 38
|
|
)
|
|
(:state-methods
|
|
ready ;; 34
|
|
idle ;; 28
|
|
spawn-up ;; 36
|
|
pre-spawn-up ;; 37
|
|
carry ;; 29
|
|
fall ;; 31
|
|
explode ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-box (mechblock)
|
|
((taskman uint64 :offset-assert 296)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x130
|
|
:flag-assert #x2200b00130
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-bomb-spawner (process-drawable)
|
|
((proc-handle uint64 :offset-assert 200)
|
|
(hint-mode uint8 :offset-assert 208)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd1
|
|
:flag-assert #x16006000d1
|
|
(:methods
|
|
(precur-bomb-spawner-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-laser-beam (process-drawable)
|
|
((laser-dir vector :inline :offset-assert 204)
|
|
(attack-id uint32 :offset-assert 220)
|
|
(org-laser-quat quaternion :inline :offset-assert 236)
|
|
(on-duration float :offset-assert 252)
|
|
(off-duration float :offset-assert 256)
|
|
(current-angle int8 :offset-assert 260)
|
|
(last-attack-time uint32 :offset-assert 264)
|
|
(counter uint8 :offset-assert 268)
|
|
(sound-id uint32 :offset-assert 272)
|
|
(actor-group uint32 :offset-assert 276)
|
|
(actor-group-count int32 :offset-assert 280)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x120
|
|
:flag-assert #x1a00a00120
|
|
(:methods
|
|
(precur-laser-beam-method-24 () none) ;; 24
|
|
(precur-laser-beam-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
telegraph ;; 21
|
|
dormant ;; 23
|
|
active ;; 20
|
|
hide ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-precura (task-manager)
|
|
((part-doom basic :offset-assert 240)
|
|
(doom-time uint64 :offset-assert 248)
|
|
(extra-time uint64 :offset-assert 256)
|
|
(doom-counter uint8 :offset-assert 264)
|
|
(faded uint8 :offset-assert 265)
|
|
(movie-played? basic :offset-assert 268)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x110
|
|
:flag-assert #x2000900110
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-spot-shadow-effect (process-drawable)
|
|
((focal-length float :offset-assert 200)
|
|
(near-clip float :offset-assert 204)
|
|
(far-clip float :offset-assert 208)
|
|
(color uint32 :offset-assert 212)
|
|
(pre-flicker-pos vector :inline :offset-assert 224)
|
|
(jmod-outer joint-mod-add-local :inline :offset-assert 240)
|
|
(jmod-inner joint-mod-add-local :inline :offset-assert 304)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x170
|
|
:flag-assert #x1800f00170
|
|
(:methods
|
|
(precur-spot-shadow-effect-method-22 () none) ;; 22
|
|
(precur-spot-shadow-effect-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
inactive ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-path (process-drawable)
|
|
((pathb basic :offset-assert 200)
|
|
(last-attack-time uint32 :offset-assert 204)
|
|
(attack-id uint32 :offset-assert 208)
|
|
(bolt basic :offset-assert 212)
|
|
(shock-part-time uint32 :offset-assert 216)
|
|
(shock-shadow-handle uint64 :offset-assert 224)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xe8
|
|
:flag-assert #x18007000e8
|
|
(:methods
|
|
(precur-path-method-22 () none) ;; 22
|
|
(precur-path-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
dormant ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-door-b (com-airlock)
|
|
((open-test basic :offset-assert 204)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x1b4
|
|
:flag-assert #x1e014001b4
|
|
;; field open-test uses ~A with a signed load.
|
|
(:state-methods
|
|
open ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern precur-bomb-bounce-reaction function)
|
|
;; (define-extern precur-bomb-handler function)
|
|
;; (define-extern precur-bomb-init-by-other function)
|
|
;; (define-extern hint-mode->string function)
|
|
;; (define-extern *laser-angles-array* array)
|
|
;; (define-extern elec-mech function)
|
|
;; (define-extern *precura-continue-sphere* object)
|
|
;; (define-extern *precura-continue2-sphere* object)
|
|
;; (define-extern *pca-sph1* object)
|
|
;; (define-extern *pca-sph2* object)
|
|
;; (define-extern process-drawable-shock-wave-effect function)
|
|
;; (define-extern precur-spot-shadow-effect-init-by-other function)
|
|
;; (define-extern precur-spot-shadow-effect-handler function)
|
|
;; (define-extern *precur-tour-lightning* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; transformq ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern transformq-copy! function) ;; (function transformq transformq transformq)
|
|
;; (define-extern matrix<-transformq! function) ;; (function matrix transformq matrix)
|
|
;; (define-extern matrix<-no-trans-transformq! function) ;; (function matrix transformq matrix)
|
|
;; (define-extern matrix<-transformq+trans! function) ;; (function matrix transformq vector matrix)
|
|
;; (define-extern matrix<-transformq+world-trans! function) ;; (function matrix transformq vector matrix)
|
|
;; (define-extern matrix<-parented-transformq! function) ;; (function matrix transformq vector matrix)
|
|
;; (define-extern matrix<-transformq+rot-offset! function) ;; (function matrix transformq vector matrix)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vent ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vent (process-drawable)
|
|
((show-particles basic :offset-assert 200)
|
|
(collect-effect basic :offset-assert 204)
|
|
(collect-effect2 basic :offset-assert 208)
|
|
(collect-effect-time uint64 :offset-assert 216)
|
|
(blocker basic :offset-assert 224)
|
|
(block-func basic :offset-assert 228)
|
|
(pickup-handle uint64 :offset-assert 232)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xf0
|
|
:flag-assert #x15007000f0
|
|
(:methods
|
|
(vent-method-20 () none) ;; 20
|
|
)
|
|
(:states
|
|
vent-wait-for-touch
|
|
vent-blocked
|
|
vent-pickup
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ecovent (vent)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xf0
|
|
:flag-assert #x15007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-eco-vent (process-drawable)
|
|
((part2 basic :offset-assert 200)
|
|
(pickup-time uint64 :offset-assert 208)
|
|
(touch-time uint64 :offset-assert 216)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xe0
|
|
:flag-assert #x16006000e0
|
|
(:state-methods
|
|
open ;; 20
|
|
close ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dark-eco-vent (process-drawable)
|
|
((part2 basic :offset-assert 200)
|
|
(pickup-time uint64 :offset-assert 208)
|
|
(touch-time uint64 :offset-assert 216)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xe0
|
|
:flag-assert #x16006000e0
|
|
(:state-methods
|
|
open ;; 20
|
|
close ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern vent-standard-event-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wind-work ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *wind-work* wind-work) ;; wind-work
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; water-flow ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flow-section (structure)
|
|
((start vector :inline :offset-assert 0)
|
|
(trailing plane :inline :offset-assert 16)
|
|
(pull-dir vector :inline :offset-assert 32)
|
|
(radial-dir vector :inline :offset-assert 48)
|
|
(speed float :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flow-section-array (inline-array-class)
|
|
((data flow-section :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flow-control (basic)
|
|
((path path-control :offset-assert 4) ;; guessed by decompiler
|
|
(speed float :offset-assert 8)
|
|
(belt-radius float :offset-assert 12)
|
|
(sections flow-section-array :offset-assert 16) ;; guessed by decompiler
|
|
(leading plane :inline :offset-assert 32)
|
|
(collide-bounds sphere :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x40
|
|
:flag-assert #xe00000040
|
|
(:methods
|
|
;; (new (symbol type process-drawable res-lump) _type_ 0)
|
|
(flow-control-method-9 () none) ;; 9 ;; (draw-path (_type_) none 9)
|
|
(flow-control-method-10 () none) ;; 10 ;; (setup (_type_) none 10)
|
|
(flow-control-method-11 () none) ;; 11 ;; (push-process (_type_ process-focusable) none 11)
|
|
(flow-control-method-12 () none) ;; 12 ;; (find-and-push-things (_type_) none 12)
|
|
(flow-control-method-13 () none) ;; 13
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-flow (process)
|
|
((root basic :offset-assert 128)
|
|
(flow basic :offset-assert 132)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x88
|
|
:flag-assert #xf00100088
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern ray-plane-equation-intersect function) ;; (function vector vector vector vector float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wind ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern update-wind function) ;; (function wind-work (array uint8) none)
|
|
;; (define-extern wind-get-hashed-index function)
|
|
;; (define-extern level-update-wind function) ;; (function wind-work none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasall-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wascity-airlock (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-airlock-small (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-elevator-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
(:state-methods
|
|
open ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tentacle (process-drawable)
|
|
((init-pos vector :inline :offset-assert 208)
|
|
(focus-pos vector :inline :offset-assert 224)
|
|
(nav-mesh basic :offset-assert 240)
|
|
(active-timer uint64 :offset-assert 248)
|
|
(fade-level float :offset-assert 256)
|
|
(sound-id-loop uint32 :offset-assert 260)
|
|
(sound-id-attack uint32 :offset-assert 264)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x10c
|
|
:flag-assert #x1a0090010c
|
|
(:state-methods
|
|
dormant ;; 20
|
|
un-dive-player ;; 21
|
|
attacking-0 ;; 22
|
|
attacking-1 ;; 23
|
|
kill-player ;; 24
|
|
wait ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern tentacle-follow-post function)
|
|
;; (define-extern tentacle-attack-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bsp ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern mem-usage-bsp-tree function) ;; (function bsp-header bsp-node memory-usage-block int none)
|
|
;; (define-extern *test-shrub* object) ;; int
|
|
;; (define-extern bsp-camera-asm function) ;; (function bsp-header vector none)
|
|
;; (define-extern print-collide-stats function) ;; (function none)
|
|
;; (define-extern level-remap-texture function) ;; (function texture-id texture-id)
|
|
;; (define-extern build-masks function) ;; (function bsp-header none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sprite ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sprite-header (structure)
|
|
((header qword 1 :offset-assert 0) ;; guessed by decompiler
|
|
(num-sprites int32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-hvdf-data (structure)
|
|
((data qword 76 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c0
|
|
:flag-assert #x9000004c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-hvdf-control (structure)
|
|
((alloc int8 76 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-aux-elem (structure)
|
|
((aux-type sprite-aux-type :offset-assert 0) ;; guessed by decompiler
|
|
(data vector 3 :offset-assert 4) ;; guessed by decompiler
|
|
(vec-data sprite-vec-data-2d :offset-assert 4)
|
|
(gif-data adgif-shader :offset-assert 8)
|
|
(aux-data sparticle-cpuinfo :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-aux-list (basic)
|
|
((num-entries int32 :offset-assert 4)
|
|
(entry int32 :offset-assert 8)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sprite-frame-data (structure)
|
|
((data UNKNOWN 42 :offset-assert 0)
|
|
(cdata vector 16 :offset-assert 0) ;; guessed by decompiler
|
|
(fdata UNKNOWN 26 :offset-assert 256)
|
|
(xy-array vector 8 :offset-assert 0) ;; guessed by decompiler
|
|
(st-array vector 4 :offset-assert 128) ;; guessed by decompiler
|
|
(xyz-array vector 4 :offset-assert 192) ;; guessed by decompiler
|
|
(hmge-scale vector :inline :offset-assert 256)
|
|
(consts vector :inline :offset-assert 272)
|
|
(pfog0 float :offset-assert 272)
|
|
(deg-to-rad float :offset-assert 276)
|
|
(min-scale float :offset-assert 280)
|
|
(inv-area float :offset-assert 284)
|
|
(adgif-giftag qword :inline :offset-assert 288) ;; gs-gif-tag :inline
|
|
(sprite-2d-giftag qword :inline :offset-assert 304) ;; gs-gif-tag :inline
|
|
(sprite-2d-giftag-2 qword :inline :offset-assert 320) ;; gs-gif-tag :inline
|
|
(sincos-01 vector :inline :offset-assert 336)
|
|
(sincos-23 vector :inline :offset-assert 352)
|
|
(sincos-45 vector :inline :offset-assert 368)
|
|
(sincos-67 vector :inline :offset-assert 384)
|
|
(sincos-89 vector :inline :offset-assert 400)
|
|
(basis-x vector :inline :offset-assert 416)
|
|
(basis-y vector :inline :offset-assert 432)
|
|
(sprite-3d-giftag qword :inline :offset-assert 448) ;; gs-gif-tag :inline
|
|
(sprite-3d-giftag-2 qword :inline :offset-assert 464) ;; gs-gif-tag :inline
|
|
(screen-shader adgif-shader :inline :offset-assert 480)
|
|
(inv-hmge-scale vector :inline :offset-assert 576)
|
|
(stq-offset vector :inline :offset-assert 592)
|
|
(stq-scale vector :inline :offset-assert 608)
|
|
(rgba-plain qword :inline :offset-assert 624)
|
|
(warp-giftag qword :inline :offset-assert 640) ;; gs-gif-tag :inline
|
|
(fog-clamp vector :inline :offset-assert 656)
|
|
(fog-min float :offset-assert 656)
|
|
(fog-max float :offset-assert 660)
|
|
(max-scale float :offset-assert 664)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2a0
|
|
:flag-assert #x9000002a0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sprite-setup-header function) ;; (function sprite-header int none)
|
|
;; (define-extern clear-sprite-aux-list function) ;; (function none)
|
|
;; (define-extern add-to-sprite-aux-list function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d uint none)
|
|
;; (define-extern sprite-setup-frame-data function) ;; (function sprite-frame-data uint none)
|
|
;; (define-extern sprite-vu1-block object) ;; vu-function
|
|
;; (define-extern sprite-set-3d-quaternion! function) ;; (function sprite-vec-data-3d quaternion quaternion)
|
|
;; (define-extern sprite-get-3d-quaternion! function) ;; (function quaternion sprite-vec-data-3d quaternion)
|
|
;; (define-extern sprite-add-matrix-data function) ;; (function dma-buffer uint none)
|
|
;; (define-extern sprite-add-frame-data function) ;; (function dma-buffer uint none)
|
|
;; (define-extern sprite-add-2d-chunk function) ;; (function sprite-array-2d int int dma-buffer int none)
|
|
;; (define-extern sprite-add-2d-all function) ;; (function sprite-array-2d dma-buffer int none)
|
|
;; (define-extern sprite-add-3d-chunk function) ;; (function sprite-array-3d int int dma-buffer none)
|
|
;; (define-extern sprite-add-3d-all function) ;; (function sprite-array-3d dma-buffer int none)
|
|
;; (define-extern sprite-draw function) ;; (function display none)
|
|
;; (define-extern sprite-allocate-user-hvdf function) ;; (function int)
|
|
;; (define-extern sprite-release-user-hvdf function) ;; (function int none)
|
|
;; (define-extern sprite-get-user-hvdf function) ;; (function int vector)
|
|
;; (define-extern *sprite-hvdf-data* object) ;; sprite-hvdf-data
|
|
;; (define-extern *sprite-hvdf-control* object) ;; sprite-hvdf-control
|
|
;; (define-extern *sprite-aux-list* object) ;; sprite-aux-list
|
|
;; (define-extern *sprite-array-2d* object) ;; sprite-array-2d
|
|
;; (define-extern *sprite-array-3d* object) ;; sprite-array-3d
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-vu0 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern generic-vu0-block object) ;; vu-function
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desbeast-path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *desbeast-path-table* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sprite-distort ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sprite-distorter-sine-tables (basic)
|
|
((aspx float :offset-assert 4)
|
|
(aspy float :offset-assert 8)
|
|
(entry vector 128 :offset-assert 16) ;; guessed by decompiler
|
|
(ientry qword 9 :offset-assert 2064) ;; guessed by decompiler
|
|
(giftag qword :inline :offset-assert 2208) ;; gs-gif-tag :inline
|
|
(color qword :inline :offset-assert 2224)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8c0
|
|
:flag-assert #x9000008c0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *sprite-distorter-sine-tables* object) ;; sprite-distorter-sine-tables
|
|
;; (define-extern sprite-distorter-generate-tables function) ;; (function none)
|
|
;; (define-extern sprite-distort-vu1-block object) ;; vu-function
|
|
;; (define-extern sprite-init-distorter function) ;; (function dma-buffer none)
|
|
;; (define-extern sprite-draw-distorters function) ;; (function dma-buffer none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; texture-anim ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *texture-anim-work* object) ;; texture-anim-work
|
|
;; (define-extern texture-anim-layer-interp function) ;; (function texture-anim-layer float none)
|
|
;; (define-extern texture-anim-layer-add-shader function) ;; (function dma-buffer texture-anim-layer int none)
|
|
;; (define-extern texture-anim-layer-add-clut-shader function) ;; (function dma-buffer texture-anim-layer int none)
|
|
;; (define-extern texture-anim-layer-draw function) ;; (function dma-buffer int int texture-anim-layer none)
|
|
;; (define-extern default-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern blend-clut-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern add-clut-texture-anim-layer-func function)
|
|
;; (define-extern dest-blend-clut-texture-anim-layer-func function)
|
|
;; (define-extern move-rg-to-ba-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern fill-rgb-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern texture-anim-draw-mip-shader function)
|
|
;; (define-extern clear-texture-ids function)
|
|
;; (define-extern texture-anim-draw-mips function)
|
|
;; (define-extern update-texture-anim function) ;; (function bucket-id texture-anim-array none)
|
|
;; (define-extern no-alpha-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern copy-alpha-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern copy-clut-alpha-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern set-alpha-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern set-clut-alpha-texture-anim-layer-func function) ;; (function dma-buffer uint int int texture-anim-layer float int)
|
|
;; (define-extern dest-texture-init function) ;; (function texture-anim none)
|
|
;; (define-extern src-texture-init function) ;; (function texture-anim-layer none)
|
|
;; (define-extern src-texture-init-mt8 function) ;; (function texture-anim-layer none)
|
|
;; (define-extern make-noise-texture function) ;; (function pointer int int int none)
|
|
;; (define-extern make-cloud-clut function) ;; (function (pointer uint32) float float none)
|
|
;; (define-extern texture-anim-cloud-clut-upload function) ;; (function dma-buffer texture-anim none)
|
|
;; (define-extern texture-anim-cloud-clut-init function) ;; (function texture-anim none)
|
|
;; (define-extern make-slime-clut function) ;; (function (pointer uint32) none)
|
|
;; (define-extern texture-anim-slime-clut-upload function) ;; (function dma-buffer texture-anim none)
|
|
;; (define-extern texture-anim-slime-clut-init function) ;; (function texture-anim none)
|
|
;; (define-extern make-ramp-clut function) ;; (function (pointer uint32) pointer object none)
|
|
;; (define-extern make-alpha-ramp-clut function) ;; (function (pointer uint32) none)
|
|
;; (define-extern noise-texture-init function) ;; (function texture-anim-layer none)
|
|
;; (define-extern texture-anim-alpha-ramp-clut-upload function) ;; (function dma-buffer texture-anim none)
|
|
;; (define-extern texture-anim-alpha-ramp-clut-init function) ;; (function texture-anim none)
|
|
;; (define-extern texture-anim-overide-size-init function) ;; (function texture-anim none)
|
|
;; (define-extern texture-anim-change-mt8h-init function) ;; (function texture-anim none)
|
|
;; (define-extern *texture-anim-pages-table* object)
|
|
;; (define-extern *texture-anim-mip-array* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; debug-sphere ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern make-debug-sphere-table function) ;; (function vector-array float float vector-array)
|
|
;; (define-extern *debug-sphere-table* object) ;; (array vector-array)
|
|
;; (define-extern add-debug-sphere-from-table function) ;; (function bucket-id vector meters rgba int none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern vehicle-explode-post function) ;; (function none :behavior vehicle)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; debug ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype debug-line (structure)
|
|
((flags int32 :offset-assert 0)
|
|
(bucket int32 :offset-assert 4) ;; bucket-id
|
|
(v1 vector :inline :offset-assert 16)
|
|
(v2 vector :inline :offset-assert 32)
|
|
(color rgba :offset-assert 48) ;; guessed by decompiler
|
|
(mode symbol :offset-assert 52) ;; guessed by decompiler
|
|
(color2 rgba :offset-assert 56) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-text-3d (structure)
|
|
((flags int32 :offset-assert 0)
|
|
(bucket int32 :offset-assert 4) ;; bucket-id
|
|
(pos vector :inline :offset-assert 16)
|
|
(color font-color :offset-assert 32) ;; guessed by decompiler
|
|
(offset vector2h :inline :offset-assert 36)
|
|
(str string :offset-assert 40) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-tracking-thang (basic)
|
|
((length int32 :offset-assert 4)
|
|
(allocated-length int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; debug-vertex-stats is already defined!
|
|
|
|
;; (define-extern transform-float-point function) ;; (function vector vector4w vector4w)
|
|
;; (define-extern add-debug-point function) ;; (function symbol bucket-id vector symbol)
|
|
;; (define-extern debug-line-clip? function) ;; (function vector vector vector vector symbol)
|
|
;; (define-extern internal-draw-debug-line function) ;; (function bucket-id vector vector rgba symbol rgba pointer)
|
|
;; (define-extern internal-draw-debug-text-3d function) ;; (function bucket-id string vector font-color vector2h pointer)
|
|
;; (define-extern add-debug-outline-triangle function) ;; (function symbol bucket-id vector vector vector rgba symbol)
|
|
;; (define-extern add-debug-triangle-normal function) ;; (function symbol bucket-id vector vector vector rgba symbol)
|
|
;; (define-extern add-debug-flat-triangle function) ;; (function symbol bucket-id vector vector vector rgba symbol)
|
|
;; (define-extern *debug-lines* object) ;; (inline-array debug-line)
|
|
;; (define-extern *debug-lines-trk* object) ;; debug-tracking-thang
|
|
;; (define-extern *debug-text-3ds* object) ;; (inline-array debug-text-3d)
|
|
;; (define-extern *debug-text-3d-trk* object) ;; debug-tracking-thang
|
|
;; (define-extern get-debug-line function) ;; (function debug-line)
|
|
;; (define-extern get-debug-text-3d function) ;; (function debug-text-3d)
|
|
;; (define-extern debug-reset-buffers function) ;; (function symbol)
|
|
;; (define-extern debug-draw-buffers function) ;; (function symbol)
|
|
;; (define-extern add-debug-line function) ;; (function symbol bucket-id vector vector rgba symbol rgba symbol)
|
|
;; (define-extern add-debug-line2d function) ;; (function symbol bucket-id vector4w vector4w vector4w symbol)
|
|
;; (define-extern add-debug-box function) ;; (function symbol bucket-id vector vector rgba symbol)
|
|
;; (define-extern add-debug-box-with-transform function) ;; (function symbol bucket-id bounding-box matrix rgba symbol)
|
|
;; (define-extern add-debug-x function) ;; (function symbol bucket-id vector rgba symbol)
|
|
;; (define-extern add-debug-cross function) ;; (function symbol bucket-id vector float symbol)
|
|
;; (define-extern add-debug-text-3d function) ;; (function symbol bucket-id string vector font-color vector2h symbol)
|
|
;; (define-extern add-debug-sphere-with-transform function) ;; (function symbol bucket-id vector meters matrix rgba symbol)
|
|
;; (define-extern add-debug-sphere function) ;; (function symbol bucket-id vector meters rgba symbol)
|
|
;; (define-extern add-debug-text-sphere function) ;; (function symbol bucket-id vector meters string rgba symbol)
|
|
;; (define-extern add-debug-spheres function) ;; (function symbol bucket-id (inline-array vector) int rgba symbol)
|
|
;; (define-extern add-debug-line-sphere function) ;; (function symbol bucket-id vector vector float rgba none)
|
|
;; (define-extern add-debug-circle function) ;; (function symbol bucket-id vector float rgba matrix symbol)
|
|
;; (define-extern add-debug-vector function) ;; (function symbol bucket-id vector vector meters rgba symbol)
|
|
;; (define-extern add-debug-matrix function) ;; (function symbol bucket-id matrix meters matrix)
|
|
;; (define-extern add-debug-rot-matrix function) ;; (function symbol bucket-id matrix vector matrix)
|
|
;; (define-extern add-debug-quaternion function) ;; (function symbol bucket-id vector quaternion none)
|
|
;; (define-extern add-debug-cspace function) ;; (function symbol bucket-id cspace cspace)
|
|
;; (define-extern add-debug-yrot-vector function) ;; (function symbol bucket-id vector float float rgba symbol)
|
|
;; (define-extern add-debug-arc function) ;; (function symbol bucket-id vector float float float rgba matrix symbol)
|
|
;; (define-extern add-debug-curve function) ;; (function symbol bucket-id (inline-array vector) int (pointer float) int rgba symbol)
|
|
;; (define-extern add-debug-curve2 function) ;; (function symbol bucket-id curve rgba symbol symbol)
|
|
;; (define-extern add-debug-points function) ;; (function symbol bucket-id (inline-array vector) int rgba float int symbol)
|
|
;; (define-extern debug-percent-bar function) ;; (function symbol bucket-id int int float rgba int int symbol)
|
|
;; (define-extern debug-pad-display function) ;; (function cpad-info symbol)
|
|
;; (define-extern add-debug-light function) ;; (function symbol bucket-id light vector string symbol)
|
|
;; (define-extern add-debug-lights function) ;; (function symbol bucket-id (inline-array light) vector symbol)
|
|
;; (define-extern drawable-frag-count function) ;; (function drawable int)
|
|
;; (define-extern history-init function) ;; (function pos-history int pos-history)
|
|
;; (define-extern history-draw-and-update function) ;; (function pos-history symbol vector symbol)
|
|
;; (define-extern dma-timeout-cam function) ;; (function vector)
|
|
;; (define-extern display-file-info function) ;; (function int)
|
|
;; (define-extern add-debug-cursor function) ;; (function symbol bucket-id int int mouse-buttons int)
|
|
;; (define-extern *boundary-polygon* object) ;; (inline-array sky-vertex)
|
|
;; (define-extern init-boundary-regs function) ;; (function none)
|
|
;; (define-extern add-boundary-shader function) ;; (function texture-id dma-buffer none)
|
|
;; (define-extern draw-boundary-polygon function)
|
|
;; (define-extern render-boundary-quad function)
|
|
;; (define-extern render-boundary-tri function) ;; (function sky-vertex dma-buffer none)
|
|
;; (define-extern add-debug-bound-internal function) ;; (function dma-buffer (inline-array vector) int rgba rgba int none)
|
|
;; (define-extern add-debug-bound function) ;; (function bucket-id (inline-array vector) int rgba rgba int none)
|
|
;; (define-extern cpu-delay function) ;; (function int none)
|
|
;; (define-extern qword-read-time function) ;; (function (array uint128) int int)
|
|
;; (define-extern bugfix? function) ;; (function symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; des-cactus ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype des-plant (process-focusable)
|
|
((exploder-params basic :offset-assert 208)
|
|
(exploder-skel basic :offset-assert 212)
|
|
(exploder-anim uint32 :offset-assert 216)
|
|
(hit-points float :offset-assert 220)
|
|
(incoming-attack-id int32 :offset-assert 224)
|
|
(exploder uint64 :offset-assert 232)
|
|
(attack-vel vector :inline :offset-assert 240)
|
|
(spring-pos vector :inline :offset-assert 256)
|
|
(spring-vel vector :inline :offset-assert 272)
|
|
(jmods UNKNOWN 4 :offset-assert 288)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x1a0
|
|
:flag-assert #x24012001a0
|
|
(:methods
|
|
(des-plant-method-30 () none) ;; 30
|
|
(des-plant-method-31 () none) ;; 31
|
|
(des-plant-method-32 () none) ;; 32
|
|
(des-plant-method-33 () none) ;; 33
|
|
(des-plant-method-34 () none) ;; 34
|
|
(des-plant-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
explode ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-cactus-a (des-plant)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x1a0
|
|
:flag-assert #x24012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-cactus-b (des-plant)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x1a0
|
|
:flag-assert #x24012001a0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *des-cactus-a-explode-params* joint-exploder-static-params)
|
|
;; (define-extern *des-cactus-b-explode-params* joint-exploder-static-params)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; merc-vu1 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern merc-vu1-block object) ;; vu-function
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-mesh ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sopt-work (structure)
|
|
((intersect vector :inline :offset-assert 0)
|
|
(sphere-bbox4w bounding-box4w :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spat-work (structure)
|
|
((intersect vector :inline :offset-assert 0)
|
|
(sphere-bbox4w bounding-box4w :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype oot-work (structure)
|
|
((intersect vector :inline :offset-assert 0)
|
|
(sphere-bbox4w bounding-box4w :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blow-tower-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tower-enemy-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(entity-name basic :offset-assert 16)
|
|
(target uint64 :offset-assert 24)
|
|
(time-offset float :offset-assert 32)
|
|
(activate-time uint64 :offset-assert 40)
|
|
(bool-userdata? basic :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blow-tower-enemy (process-focusable)
|
|
((hit-points float :offset-assert 208)
|
|
(last-attack-id uint32 :offset-assert 212)
|
|
(last-attack-dir vector :inline :offset-assert 224)
|
|
(last-attack-pos vector :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x100
|
|
:flag-assert #x2600800100
|
|
(:methods
|
|
(blow-tower-enemy-method-30 () none) ;; 30
|
|
(blow-tower-enemy-method-31 () none) ;; 31
|
|
(blow-tower-enemy-method-32 () none) ;; 32
|
|
(blow-tower-enemy-method-33 () none) ;; 33
|
|
(blow-tower-enemy-method-34 () none) ;; 34
|
|
(blow-tower-enemy-method-35 () none) ;; 35
|
|
(blow-tower-enemy-method-36 () none) ;; 36
|
|
(blow-tower-enemy-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
dormant ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tower-flyer-bobber (structure)
|
|
((start-val float :offset-assert 0)
|
|
(current-val float :offset-assert 4)
|
|
(total-time uint64 :offset-assert 8)
|
|
(current-time uint64 :offset-assert 16)
|
|
(current-size-scalar float :offset-assert 24)
|
|
(dir float :offset-assert 28)
|
|
(num-iterations float :offset-assert 32)
|
|
(time-scalar float :offset-assert 36)
|
|
(start-time-scalar float :offset-assert 40)
|
|
(desired-time-scalar float :offset-assert 44)
|
|
(scale-min float :offset-assert 48)
|
|
(scale-max float :offset-assert 52)
|
|
(time-min float :offset-assert 56)
|
|
(time-max float :offset-assert 60)
|
|
(base-time float :offset-assert 64)
|
|
(current-speed float :offset-assert 68)
|
|
(output-scale float :offset-assert 72)
|
|
(output-val float :offset-assert 76)
|
|
(charge-time uint64 :offset-assert 80)
|
|
(wait-time uint64 :offset-assert 88)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x60
|
|
:flag-assert #xc00000060
|
|
(:methods
|
|
(tower-flyer-bobber-method-9 () none) ;; 9
|
|
(tower-flyer-bobber-method-10 () none) ;; 10
|
|
(tower-flyer-bobber-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tower-flyer (blow-tower-enemy)
|
|
((focus uint64 :offset-assert 256)
|
|
(local-offset vector :inline :offset-assert 272)
|
|
(basetrans vector :inline :offset-assert 288)
|
|
(surround-spot int32 :offset-assert 304)
|
|
(desired-z-dist float :offset-assert 308)
|
|
(current-z-dist float :offset-assert 312)
|
|
(use-z-dist float :offset-assert 316)
|
|
(bobbers UNKNOWN 3 :offset-assert 320)
|
|
(spot-base-pos vector :inline :offset-assert 608)
|
|
(hover-end-time uint64 :offset-assert 624)
|
|
(total-charge-time uint64 :offset-assert 624)
|
|
(charge-part basic :offset-assert 632)
|
|
(charge-t float :offset-assert 636)
|
|
(last-wall-clip-time uint64 :offset-assert 640)
|
|
(spawn-path-time uint64 :offset-assert 648)
|
|
(bob-vec vector :inline :offset-assert 656)
|
|
(bob-y-scalar float :offset-assert 672)
|
|
(entity-pos vector :offset-assert 676)
|
|
(buzz-sound uint32 :offset-assert 680)
|
|
(charge-sound uint32 :offset-assert 684)
|
|
)
|
|
:method-count-assert 50
|
|
:size-assert #x2b0
|
|
:flag-assert #x32023002b0
|
|
(:methods
|
|
(tower-flyer-method-42 () none) ;; 42
|
|
(tower-flyer-method-43 () none) ;; 43
|
|
(tower-flyer-method-44 () none) ;; 44
|
|
(tower-flyer-method-45 () none) ;; 45
|
|
(tower-flyer-method-46 () none) ;; 46
|
|
(tower-flyer-method-47 () none) ;; 47
|
|
(tower-flyer-method-48 () none) ;; 48
|
|
(tower-flyer-method-49 () none) ;; 49
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
hovering ;; 38
|
|
charging ;; 39
|
|
fleeing ;; 41
|
|
firing ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flyer-projectile-params (structure)
|
|
((total-travel-time uint64 :offset-assert 0)
|
|
(target uint64 :offset-assert 8)
|
|
(damage float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flyer-projectile (process-drawable)
|
|
((original-offset-vec vector :inline :offset-assert 208)
|
|
(params flyer-projectile-params :inline :offset-assert 224)
|
|
(size-t float :offset-assert 244)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xf8
|
|
:flag-assert #x16008000f8
|
|
(:methods
|
|
(flyer-projectile-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cast-rider (process-focusable)
|
|
((anim-index int16 :offset-assert 208)
|
|
(track-obj uint64 :offset-assert 216)
|
|
(neck basic :offset-assert 224)
|
|
(track-pos vector :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
(:state-methods
|
|
riding ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-barrel (blow-tower-enemy)
|
|
((nearby-barrels UNKNOWN 16 :offset-assert 256)
|
|
(nearby-barrel-pos UNKNOWN 16 :offset-assert 384)
|
|
(nearby-barrel-dist UNKNOWN 16 :offset-assert 640)
|
|
(num-nearby-barrels int32 :offset-assert 704)
|
|
(barrel-send-index int32 :offset-assert 708)
|
|
(barrel-live-mask uint32 :offset-assert 712)
|
|
(rot-vec vector :inline :offset-assert 720)
|
|
(rot-speed float :offset-assert 736)
|
|
)
|
|
:method-count-assert 44
|
|
:size-assert #x2e4
|
|
:flag-assert #x2c027002e4
|
|
(:methods
|
|
(bt-barrel-method-40 () none) ;; 40
|
|
(bt-barrel-method-41 () none) ;; 41
|
|
(bt-barrel-method-42 () none) ;; 42
|
|
(bt-barrel-method-43 () none) ;; 43
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
explode ;; 38
|
|
fly-up ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-barrel-stack (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
barrel-spawning ;; 21
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-pickup-barrel (process-drawable)
|
|
((index int32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
riding ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern blow-tower-enemy-handler function)
|
|
;; (define-extern tower-flyer-init-by-other function)
|
|
;; (define-extern *current-color* object)
|
|
;; (define-extern tower-fly-quick-raycast function)
|
|
;; (define-extern compute-tower-flyer-lerp-point function)
|
|
;; (define-extern flyer-projectile-init-by-other function)
|
|
;; (define-extern cast-rider-init-by-other function)
|
|
;; (define-extern bt-barrel-init-by-other function)
|
|
;; (define-extern barrel-stack-init-by-other function)
|
|
;; (define-extern bt-barrel-ground-probe function)
|
|
;; (define-extern setup-bt-barrels function)
|
|
;; (define-extern attempt-barrel-spawn function)
|
|
;; (define-extern bt-pickup-barrel-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasteland-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; robo-hover ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype robo-hover-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype robo-hover (hover-enemy)
|
|
((wrist-quat UNKNOWN 2 :offset-assert 976)
|
|
(aim-position vector :inline :offset-assert 1008)
|
|
(entity-group basic :offset-assert 1024)
|
|
(smoke-part basic :offset-assert 1028)
|
|
(engine-part basic :offset-assert 1032)
|
|
(next-fire-time uint64 :offset-assert 1040)
|
|
(gun-blend float :offset-assert 1048)
|
|
(path-u float :offset-assert 1052)
|
|
(path-du float :offset-assert 1056)
|
|
(path-du-final float :offset-assert 1060)
|
|
(path-dest float :offset-assert 1064)
|
|
(sound-id uint32 :offset-assert 1068)
|
|
(knocked-recover-anim int32 :offset-assert 1072)
|
|
(attack-wait-min float :offset-assert 1076)
|
|
(attack-wait-max float :offset-assert 1080)
|
|
(attack-miss-dist-min float :offset-assert 1084)
|
|
(attack-miss-dist-max float :offset-assert 1088)
|
|
(attack-miss-dist-curr float :offset-assert 1092)
|
|
(shots-fired int32 :offset-assert 1096)
|
|
)
|
|
:method-count-assert 184
|
|
:size-assert #x44c
|
|
:flag-assert #xb803d0044c
|
|
(:methods
|
|
(robo-hover-method-182 () none) ;; 182
|
|
(robo-hover-method-183 () none) ;; 183
|
|
)
|
|
(:state-methods
|
|
knocked ;; 31
|
|
ambush ;; 47
|
|
ambush-fly ;; 177
|
|
ambush-attack ;; 178
|
|
kick-attack ;; 179
|
|
notice ;; 35
|
|
hostile ;; 38
|
|
attack ;; 180
|
|
knocked-recover ;; 32
|
|
explode ;; 181
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-robo-hover-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *robo-hover-enemy-info* enemy-info)
|
|
;; (define-extern *robo-hover-debris-params* debris-static-params)
|
|
;; (define-extern exit-ambush? function)
|
|
;; (define-extern robo-hover-arm-jmod function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; merc-blend-shape ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype blerc-block-header (structure)
|
|
((tag generic-merc-tag :inline :offset-assert 0)
|
|
(vtx-count uint32 :offset-assert 16)
|
|
(overlap uint32 :offset-assert 20)
|
|
(lump-dest uint32 :offset-assert 24)
|
|
(lump-qwc uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blerc-block (structure)
|
|
((output uint8 848 :offset-assert 0) ;; guessed by decompiler
|
|
(header blerc-block-header :inline :offset-assert 848)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x370
|
|
:flag-assert #x900000370
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blerc-dcache (structure)
|
|
((repl-mult vector 40 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x280
|
|
:flag-assert #x900000280
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blerc-globals (structure)
|
|
((first uint32 :offset-assert 0)
|
|
(next uint32 :offset-assert 4)
|
|
(min-val int16 :offset-assert 8)
|
|
(max-val int16 :offset-assert 10)
|
|
(fragment-count int32 :offset-assert 12)
|
|
(vtx-count int32 :offset-assert 16)
|
|
(target-vtx-count int32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blerc-context (structure)
|
|
((block-a blerc-block :inline :offset-assert 0)
|
|
(dummy uint8 7312 :offset-assert 880) ;; guessed by decompiler
|
|
(block-b blerc-block :inline :offset-assert 8192)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2370
|
|
:flag-assert #x900002370
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *stats-blerc* object) ;; symbol
|
|
;; (define-extern *blerc-globals* object) ;; blerc-globals
|
|
;; (define-extern blerc-stats-init function) ;; (function none)
|
|
;; (define-extern blerc-init function) ;; (function none)
|
|
;; (define-extern blerc-a-fragment function)
|
|
;; (define-extern dma-from-spr function)
|
|
;; (define-extern merc-dma-chain-to-spr function)
|
|
;; (define-extern blerc-execute function) ;; (function none)
|
|
;; (define-extern merc-blend-shape function) ;; (function process-drawable object)
|
|
;; (define-extern setup-blerc-chains-for-one-fragment function) ;; (function object object object object object object object)
|
|
;; (define-extern setup-blerc-chains function) ;; (function merc-ctrl (pointer int16) dma-buffer none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; merc ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; merc-fragment-control is already defined!
|
|
|
|
;; merc-ctrl is already defined!
|
|
|
|
;; (define-extern *texture-login-data* object) ;; texture-login-data
|
|
;; (define-extern texture-usage-init function) ;; (function merc-ctrl symbol)
|
|
;; (define-extern texture-usage-update function) ;; (function texture symbol)
|
|
;; (define-extern merc-stats-display function) ;; (function merc-ctrl none)
|
|
;; (define-extern merc-stats function) ;; (function none)
|
|
;; (define-extern merc-edge-stats function) ;; (function none)
|
|
;; (define-extern merc-vu1-add-vu-function function) ;; (function dma-packet vu-function int dma-gif-packet)
|
|
;; (define-extern merc-vu1-initialize-chain function) ;; (function dma-gif-packet int dma-packet)
|
|
;; (define-extern merc-vu1-init-buffer function) ;; (function bucket-id int symbol int)
|
|
;; (define-extern merc-vu1-init-buffers function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; emerc ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern emerc-vu1-initialize-chain function) ;; (function dma-gif-packet dma-packet)
|
|
;; (define-extern emerc-vu1-init-buffer function) ;; (function bucket-id gs-test int none)
|
|
;; (define-extern emerc-vu1-init-buffers function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; h-glider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype glider-asc (structure)
|
|
((asc float :offset-assert 0)
|
|
(des float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *h-glider-constants* object)
|
|
;; (define-extern glider-impact-reduction function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ripple ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ripple-request (structure)
|
|
((waveform ripple-wave :offset-assert 0) ;; guessed by decompiler
|
|
(effect merc-effect :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ripple-globals (structure)
|
|
((count int32 :offset-assert 0)
|
|
(requests ripple-request 16 :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x84
|
|
:flag-assert #x900000084
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ripple-globals* object) ;; ripple-globals
|
|
;; (define-extern ripple-make-request function) ;; (function ripple-wave merc-effect none)
|
|
;; (define-extern ripple-update-waveform-offs function) ;; (function ripple-wave-set clock none)
|
|
;; (define-extern ripple-execute-init function) ;; (function none)
|
|
;; (define-extern ripple-create-wave-table function) ;; (function ripple-wave-set int)
|
|
;; (define-extern ripple-apply-wave-table function) ;; (function merc-effect symbol)
|
|
;; (define-extern ripple-execute function) ;; (function none)
|
|
;; (define-extern ripple-matrix-scale function) ;; function
|
|
;; (define-extern ripple-add-debug-sphere function) ;; (function process-drawable vector float float none)
|
|
;; (define-extern ripple-slow-add-sine-waves function) ;; (function ripple-wave-set float float float)
|
|
;; (define-extern ripple-find-height function) ;; (function process-drawable int vector float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; debug-foreground ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern diag-frag-print function)
|
|
;; (define-extern debug-merc-highres-runtime function)
|
|
;; (define-extern debug-merc-size-runtime function)
|
|
;; (define-extern debug-merc-fade-runtime function)
|
|
;; (define-extern foreground-check-longest-edge function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; credits-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *credits-ids* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; foreground ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern foreground-vu0-block object) ;; vu-function
|
|
;; (define-extern *bucket-map* object) ;; (pointer bucket-id-16)
|
|
;; (define-extern vu1-bucket-map function) ;; (function int int merc-mode bucket-id)
|
|
;; (define-extern generic-bucket-state-init function) ;; (function generic-bucket-state none)
|
|
;; (define-extern mercneric-chain-init function) ;; (function mercneric-chain bucket-id none)
|
|
;; (define-extern foreground-init function) ;; (function none)
|
|
;; (define-extern texscroll-make-request function) ;; (function merc-effect none)
|
|
;; (define-extern texscroll-execute function) ;; (function none)
|
|
;; (define-extern vu-lights<-light-group! function) ;; (function vu-lights light-group none)
|
|
;; (define-extern foreground-add-mtx-calc function) ;; (function bone-calculation (inline-array pris-mtx) bone-calc-flags bone-calculation)
|
|
;; (define-extern foreground-wrapup function) ;; (function none)
|
|
;; (define-extern *default-shadow-settings* object) ;; shadow-settings
|
|
;; (define-extern foreground-shadow function) ;; (function draw-control (inline-array pris-mtx) pointer pointer)
|
|
;; (define-extern foreground-generic-merc-death function) ;; (function draw-control generic-merc-ctrl none)
|
|
;; (define-extern foreground-generic-merc-add-fragments function) ;; (function merc-effect pointer mercneric-chain pointer)
|
|
;; (define-extern foreground-generic-merc function) ;; (function draw-control pointer int pointer)
|
|
;; (define-extern foreground-merc function) ;; (function draw-control (inline-array pris-mtx) pointer int int object pointer)
|
|
;; (define-extern foreground-emerc function) ;; (function draw-control (inline-array pris-mtx) pointer object int int pointer)
|
|
;; (define-extern foreground-check-longest-edge-asm function) ;; (function draw-control float symbol)
|
|
;; (define-extern foreground-ripple function) ;; (function draw-control merc-ctrl pointer int pointer)
|
|
;; (define-extern foreground-draw function) ;; (function draw-control dma-buffer float none)
|
|
;; (define-extern foreground-draw-hud function) ;; (function draw-control dma-buffer float none)
|
|
;; (define-extern *foreground* object) ;; foreground-globals
|
|
;; (define-extern *foreground-draw-engine* object) ;; engine
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-indax ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *indax-walk-mods* object) ;; surface
|
|
;; (define-extern *indax-jump-mods* object) ;; surface
|
|
;; (define-extern *indax-double-jump-mods* object) ;; surface
|
|
;; (define-extern *indax-bounce-mods* object) ;; surface
|
|
;; (define-extern target-indax-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-indax-dangerous-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-indax-jump-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-indax-reset function)
|
|
;; (define-extern target-indax-init function) ;; (function none :behavior target)
|
|
;; (define-extern target-indax-exit function) ;; (function none :behavior target)
|
|
;; (define-extern target-indax-real-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-indax-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-indax-hit-setup-anim function) ;; (function attack-info none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern init-ocean-far-regs function) ;; (function none)
|
|
;; (define-extern draw-large-polygon-ocean function) ;; (function none)
|
|
;; (define-extern render-ocean-quad function) ;; (function (inline-array ocean-vertex) dma-buffer symbol)
|
|
;; (define-extern test-seq-read function)
|
|
;; (define-extern test-worst-read function)
|
|
;; (define-extern test-seq-write function)
|
|
;; (define-extern test-worst-write function)
|
|
;; (define-extern test-to-spr function)
|
|
;; (define-extern test-from-spr function)
|
|
;; (define-extern test-to-from-spr function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; saberfish-spawner ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; path-index-array is already defined!
|
|
|
|
#|
|
|
(deftype nav-mesh-jump (structure)
|
|
((mesh basic :offset-assert 0)
|
|
(paths basic :offset-assert 4)
|
|
(in-water? basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-jump-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish-spawner-command (structure)
|
|
((command basic :offset-assert 0)
|
|
(message basic :offset-assert 4)
|
|
(initial-state basic :offset-assert 8)
|
|
(parent uint64 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish-spawn-query (structure)
|
|
((alive-count int16 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish-spawner (process-drawable)
|
|
((jump-paths basic :offset-assert 200)
|
|
(nav-mesh-jumps basic :offset-assert 204)
|
|
(live-count int8 :offset-assert 208)
|
|
(last-spawned-process uint64 :offset-assert 216)
|
|
(mgr-parent uint64 :offset-assert 224)
|
|
(spawned-saberfish UNKNOWN 128 :offset-assert 232)
|
|
(num-spawned-saberfish int32 :offset-assert 1256)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #x4ec
|
|
:flag-assert #x1b047004ec
|
|
(:methods
|
|
(saberfish-spawner-method-21 () none) ;; 21
|
|
(saberfish-spawner-method-22 () none) ;; 22
|
|
(saberfish-spawner-method-23 () none) ;; 23
|
|
(saberfish-spawner-method-24 () none) ;; 24
|
|
(saberfish-spawner-method-25 () none) ;; 25
|
|
(saberfish-spawner-method-26 () none) ;; 26
|
|
)
|
|
(:state-methods
|
|
saberfish-spawner-base-state ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish-spawn-manager-base (process)
|
|
((actor-group uint32 :offset-assert 124)
|
|
(actor-group-count int32 :offset-assert 128)
|
|
(total-num-spawned int32 :offset-assert 132)
|
|
(total-alive int32 :offset-assert 136)
|
|
(spawn-timer uint64 :offset-assert 140)
|
|
(state-time uint64 :offset-assert 148)
|
|
(allowed-on-land-count int8 :offset-assert 156)
|
|
)
|
|
:method-count-assert 19
|
|
:size-assert #xa1
|
|
:flag-assert #x13003000a1
|
|
(:methods
|
|
(saberfish-spawn-manager-base-method-16 () none) ;; 16
|
|
(saberfish-spawn-manager-base-method-17 () none) ;; 17
|
|
(saberfish-spawn-manager-base-method-18 () none) ;; 18
|
|
)
|
|
(:state-methods
|
|
active ;; 14
|
|
idle ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish-mgr-room1 (saberfish-spawn-manager-base)
|
|
()
|
|
:method-count-assert 19
|
|
:size-assert #xa1
|
|
:flag-assert #x13003000a1
|
|
(:state-methods
|
|
active ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish-mgr-room2 (saberfish-spawn-manager-base)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xa1
|
|
:flag-assert #x16003000a1
|
|
(:state-methods
|
|
stage-0 ;; 19
|
|
stage-1 ;; 20
|
|
stage-2 ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *temporary-closest-nav-mesh-indices* object)
|
|
;; (define-extern *temporary-num-paths-per-nav-mesh-count* object)
|
|
;; (define-extern saberfish-mgr-event-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-tie ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; gsf-vertex is already defined!
|
|
|
|
;; (define-extern generic-tie-dma-to-spad function)
|
|
;; (define-extern generic-tie-dma-to-spad-sync function)
|
|
;; (define-extern *generic-tie* object)
|
|
;; (define-extern generic-tie-decompress function)
|
|
;; (define-extern generic-tie-upload-next function)
|
|
;; (define-extern generic-tie-convert-proc function)
|
|
;; (define-extern generic-tie-convert function)
|
|
;; (define-extern generic-tie-display-stats function)
|
|
;; (define-extern generic-tie-debug function)
|
|
;; (define-extern generic-tie-execute function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; trajectory ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern traj2d-calc-initial-speed-using-tilt function) ;; (function traj2d-params symbol)
|
|
;; (define-extern traj3d-calc-initial-velocity-using-tilt function) ;; (function traj3d-params symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; shadow-vu1 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype shadow-vu1-constants (structure)
|
|
((hmgescale vector :inline :offset-assert 0)
|
|
(invhscale vector :inline :offset-assert 16)
|
|
(texoffset vector :inline :offset-assert 32)
|
|
(texscale vector :inline :offset-assert 48)
|
|
(hvdfoff vector :inline :offset-assert 64)
|
|
(fog vector :inline :offset-assert 80)
|
|
(clrs vector 2 :offset-assert 96) ;; guessed by decompiler
|
|
(adgif gs-gif-tag :inline :offset-assert 128)
|
|
(texflush gs-adcmd :inline :offset-assert 144)
|
|
(flush gs-adcmd :inline :offset-assert 160)
|
|
(trigif gs-gif-tag :inline :offset-assert 176)
|
|
(quadgif gs-gif-tag :inline :offset-assert 192)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xd0
|
|
:flag-assert #x9000000d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shadow-vu1-data (structure)
|
|
((adgif gs-gif-tag :inline :offset-assert 0)
|
|
(ad gs-adcmd :inline :offset-assert 16)
|
|
(flush gs-adcmd :inline :offset-assert 32)
|
|
(trigif gs-gif-tag :inline :offset-assert 48)
|
|
(quadgif gs-gif-tag :inline :offset-assert 64)
|
|
(texoffset vector :inline :offset-assert 80)
|
|
(texscale vector :inline :offset-assert 96)
|
|
(clrs qword 2 :offset-assert 112) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *shadow-vu1-data* object) ;; shadow-vu1-data
|
|
;; (define-extern shadow-vu1-block object) ;; vu-function
|
|
;; (define-extern shadow-vu1-add-constants function) ;; (function dma-buffer int none)
|
|
;; (define-extern shadow-vu1-patch-consts function) ;; (function symbol int none)
|
|
;; (define-extern shadow-vu1-add-matrix function) ;; (function dma-buffer math-camera none)
|
|
;; (define-extern shadow-vu1-init-buffer function) ;; (function dma-buffer int none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; comb-travel ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-tube-ride (task-manager)
|
|
((suck-factor float :offset-assert 240)
|
|
(hp-scale float :offset-assert 244)
|
|
(intro-sequence basic :offset-assert 248)
|
|
(outro-sequence basic :offset-assert 252)
|
|
(no-shoot-time uint64 :offset-assert 256)
|
|
(end-sphere sphere :inline :offset-assert 272)
|
|
(end-plane vector :inline :offset-assert 288)
|
|
(intro-sphere sphere :inline :offset-assert 304)
|
|
(outro-sphere sphere :inline :offset-assert 320)
|
|
(intro-target vector :inline :offset-assert 336)
|
|
(outro-target vector :inline :offset-assert 352)
|
|
(outro-plane2 vector :inline :offset-assert 368)
|
|
(outro-target2 vector :inline :offset-assert 384)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x190
|
|
:flag-assert #x2101100190
|
|
(:methods
|
|
(task-manager-tube-ride-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
complete ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-comb-travel (task-manager-tube-ride)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #x190
|
|
:flag-assert #x2101100190
|
|
(:state-methods
|
|
complete ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-comb-wild-ride (task-manager-tube-ride)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #x190
|
|
:flag-assert #x2101100190
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; warp ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern fx-copy-buf function) ;; (function dma-buffer none)
|
|
;; (define-extern *warp-shader* object) ;; adgif-shader
|
|
;; (define-extern create-blanket function) ;; (function symbol)
|
|
;; (define-extern *warp* object) ;; symbol
|
|
;; (define-extern warp-test function) ;; (function object object int none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blit-displays ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *blit-displays-work* object) ;; blit-displays-work
|
|
;; (define-extern draw-color-bars function) ;; (function none)
|
|
;; (define-extern draw-raw-image function) ;; (function bucket-id art-group int int level int none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precura-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern sparticle-track-joint-xz function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; font-data ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *font12-table* object) ;; (inline-array vector)
|
|
;; (define-extern *font24-table* object) ;; (inline-array vector)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; font ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern draw-string-asm function) ;; (function string dma-buffer font-context draw-string-result)
|
|
;; (define-extern draw-string function) ;; (function string dma-buffer font-context draw-string-result)
|
|
;; (define-extern get-string-length function) ;; (function string font-context draw-string-result)
|
|
;; (define-extern draw-string-xy function) ;; (function string dma-buffer int int font-color font-flags draw-string-result)
|
|
;; (define-extern draw-string-adv function) ;; (function string dma-buffer font-context none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; des-bbush-tasks ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-wasbbv-goal (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-wasbbv-score (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-wasbbv-counter (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wasbbv-hud-info (structure)
|
|
((goal float :offset-assert 0)
|
|
(score float :offset-assert 4)
|
|
(current float :offset-assert 8)
|
|
(goal-cup uint8 :offset-assert 12)
|
|
(goal-text uint32 :offset-assert 16)
|
|
(score-text uint32 :offset-assert 20)
|
|
(decimal-place-count int8 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x19
|
|
:flag-assert #x900000019
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-vehicle-bbush (task-manager)
|
|
((ground-pos vector :inline :offset-assert 240)
|
|
(ground-time uint64 :offset-assert 256)
|
|
(pre-start-time uint64 :offset-assert 264)
|
|
(display-units float :offset-assert 272)
|
|
(max-distance float :offset-assert 276)
|
|
(distance float :offset-assert 280)
|
|
(total-distance float :offset-assert 284)
|
|
(max-air-time float :offset-assert 288)
|
|
(air-time float :offset-assert 292)
|
|
(total-air-time float :offset-assert 296)
|
|
(goal float :offset-assert 300)
|
|
(score float :offset-assert 304)
|
|
(current float :offset-assert 308)
|
|
(hud-score uint64 :offset-assert 312)
|
|
(hud-goal uint64 :offset-assert 320)
|
|
(squad-manager uint64 :offset-assert 336)
|
|
(game-score uint8 :offset-assert 344)
|
|
(last-cup uint8 :offset-assert 345)
|
|
(goal-cup uint8 :offset-assert 346)
|
|
(new-high-score basic :offset-assert 348)
|
|
(want-current-hud? basic :offset-assert 352)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x164
|
|
:flag-assert #x2500f00164
|
|
(:methods
|
|
(task-manager-vehicle-bbush-method-33 () none) ;; 33
|
|
(task-manager-vehicle-bbush-method-34 () none) ;; 34
|
|
(task-manager-vehicle-bbush-method-35 () none) ;; 35
|
|
(task-manager-vehicle-bbush-method-36 () none) ;; 36
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
report ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-air-time (task-manager-vehicle-bbush)
|
|
()
|
|
:method-count-assert 37
|
|
:size-assert #x164
|
|
:flag-assert #x2500f00164
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-total-air-time (task-manager-vehicle-bbush)
|
|
()
|
|
:method-count-assert 37
|
|
:size-assert #x164
|
|
:flag-assert #x2500f00164
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-jump-distance (task-manager-vehicle-bbush)
|
|
()
|
|
:method-count-assert 37
|
|
:size-assert #x188
|
|
:flag-assert #x2501100188
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-total-jump-distance (task-manager-vehicle-bbush)
|
|
()
|
|
:method-count-assert 37
|
|
:size-assert #x164
|
|
:flag-assert #x2500f00164
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-roll-count (task-manager-vehicle-bbush)
|
|
((roll-count float :offset-assert 356)
|
|
(y-proj float :offset-assert 360)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x16c
|
|
:flag-assert #x2500f0016c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-destroy-interceptors (task-manager-vehicle-bbush)
|
|
((max-reserve-count int32 :offset-assert 356)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x168
|
|
:flag-assert #x2500f00168
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *wasbbv-hud-info* object)
|
|
;; (define-extern *bbv-fail-time-expired* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyslumc-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; region ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern region-tree-execute function) ;; (function symbol vector vector none)
|
|
;; (define-extern region-execute function) ;; (function none)
|
|
;; (define-extern region-prim-lookup-by-id function) ;; (function int symbol int drawable-region-prim)
|
|
;; (define-extern region-lookup-by-id function) ;; (function int region)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; logic-target ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern build-conversions function) ;; (function vector vector :behavior target)
|
|
;; (define-extern vector-turn-to function) ;; (function vector vector :behavior target)
|
|
;; (define-extern reverse-conversions function) ;; (function vector none :behavior target)
|
|
;; (define-extern draw-history function) ;; (function control-info none)
|
|
;; (define-extern target-history-print function)
|
|
;; (define-extern target-print-stats function) ;; (function target symbol symbol)
|
|
;; (define-extern read-pad function) ;; (function vector vector :behavior target)
|
|
;; (define-extern set-pad function) ;; (function vector vector :behavior target)
|
|
;; (define-extern warp-vector-into-surface! function) ;; (function vector vector vector matrix vector)
|
|
;; (define-extern vector<-pad-in-surface! function) ;; (function vector symbol vector :behavior target)
|
|
;; (define-extern vector<-pad-in-matrix! function) ;; (function vector cpad-info matrix none)
|
|
;; (define-extern local-pad-angle function) ;; (function float :behavior target)
|
|
;; (define-extern turn-around? function) ;; (function symbol :behavior target)
|
|
;; (define-extern wall-hide? function) ;; (function symbol :behavior target)
|
|
;; (define-extern target-log-trans function) ;; (function none :behavior target)
|
|
;; (define-extern target-move-dist function) ;; (function time-frame float :behavior target)
|
|
;; (define-extern turn-to-vector function) ;; (function vector float symbol :behavior target)
|
|
;; (define-extern target-bend-vel-turn function) ;; (function vector vector :behavior target)
|
|
;; (define-extern target-add-slide-factor function) ;; (function vector vector :behavior target)
|
|
;; (define-extern add-thrust function) ;; (function symbol :behavior target)
|
|
;; (define-extern add-gravity function) ;; (function vector :behavior target)
|
|
;; (define-extern target-compute-slopes function) ;; (function vector int :behavior target)
|
|
;; (define-extern do-rotations1 function) ;; (function quaternion :behavior target)
|
|
;; (define-extern *strafe-mode* object)
|
|
;; (define-extern do-rotations2 function) ;; (function int :behavior target)
|
|
;; (define-extern leg-ik-callback function) ;; (function joint-mod-ik object object vector none)
|
|
;; (define-extern target-update-ik function) ;; (function none :behavior target)
|
|
;; (define-extern pre-collide-setup function) ;; (function none :behavior target)
|
|
;; (define-extern level-setup function) ;; (function none :behavior target)
|
|
;; (define-extern flag-setup function) ;; (function none :behavior target)
|
|
;; (define-extern post-flag-setup function) ;; (function none :behavior target)
|
|
;; (define-extern bend-gravity function) ;; (function symbol :behavior target)
|
|
;; (define-extern target-compute-edge function) ;; (function none :behavior target)
|
|
;; (define-extern target-compute-edge-rider function) ;; (function none :behavior target)
|
|
;; (define-extern target-compute-pole function) ;; (function none :behavior target)
|
|
;; (define-extern target-calc-camera-pos function) ;; (function none :behavior target)
|
|
;; (define-extern joint-points function) ;; (function none :behavior target)
|
|
;; (define-extern do-target-gspot function) ;; (function none :behavior target)
|
|
;; (define-extern target-real-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-swim-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-no-stick-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-no-move-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-no-ja-move-post function) ;; (function none :behavior target)
|
|
;; (define-extern reset-target-state function) ;; (function symbol target :behavior target)
|
|
;; (define-extern target-init function) ;; (function continue-point none :behavior target)
|
|
;; (define-extern tobot-init function) ;; (function symbol none :behavior target)
|
|
;; (define-extern stop function) ;; (function symbol int)
|
|
;; (define-extern start function) ;; (function symbol continue-point target)
|
|
;; (define-extern tobot-start function) ;; (function symbol target)
|
|
;; (define-extern tobot-stop function) ;; (function int)
|
|
;; (define-extern *target-geo-control* object)
|
|
;; (define-extern *target-anim-control* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; background ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *background-work* object) ;; background-work
|
|
;; (define-extern background-vu0-block object) ;; vu-function
|
|
;; (define-extern background-upload-vu0 function) ;; (function none)
|
|
;; (define-extern init-background function) ;; (function none)
|
|
;; (define-extern upload-vis-bits function) ;; (function level level bsp-header none)
|
|
;; (define-extern set-background-regs! function) ;; (function level none)
|
|
;; (define-extern set-tie-quard-planes! function) ;; (function level none)
|
|
;; (define-extern set-shrub-quard-planes! function) ;; (function level none)
|
|
;; (define-extern set-subdivide-settings! function)
|
|
;; (define-extern finish-background function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; draw-node ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype drawable-inline-array-node (drawable-inline-array)
|
|
((length int16 :offset-assert 2)
|
|
(data draw-node :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x44
|
|
:flag-assert #x1100000044
|
|
)
|
|
|#
|
|
|
|
;; (define-extern draw-node-cull function) ;; (function pointer pointer (inline-array draw-node) int none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; voicebox ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype camera-remote (camera-slave)
|
|
()
|
|
:method-count-assert 14
|
|
:size-assert #xac0
|
|
:flag-assert #xe0a400ac0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype remote (process-drawable)
|
|
((base-trans vector :inline :offset-assert 208)
|
|
(focus focus :inline :offset-assert 224)
|
|
(seeker cam-float-seeker :inline :offset-assert 236)
|
|
(start-time uint64 :offset-assert 264) ;; time-frame
|
|
(blend float :offset-assert 272)
|
|
(twist float :offset-assert 276)
|
|
(speak-effect? basic :offset-assert 280)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x11c
|
|
:flag-assert #x1a00a0011c
|
|
(:methods
|
|
(remote-method-23 () none) ;; 23 ;; (init (_type_) none 23)
|
|
(remote-method-24 () none) ;; 24 ;; (get-track-pt-and-scale (_type_ vector) float 24)
|
|
(remote-method-25 () none) ;; 25 ;; (post-common (_type_) none 25)
|
|
)
|
|
(:state-methods
|
|
enter ;; 20, old: (enter () _type_ :state 20)
|
|
idle ;; 21, old: (idle () _type_ :state 21)
|
|
exit ;; 22, old: (exit () _type_ :state 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype voicebox (remote)
|
|
((hint uint64 :offset-assert 288) ;; handle
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x128
|
|
:flag-assert #x1a00b00128
|
|
(:state-methods
|
|
exit ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype judge (remote)
|
|
((total-time uint64 :offset-assert 288) ;; time-frame
|
|
(beep-time uint64 :offset-assert 296) ;; time-frame
|
|
(hud-timer uint64 :offset-assert 304) ;; handle
|
|
(score uint8 :offset-assert 312)
|
|
(timer? basic :offset-assert 316)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #x140
|
|
:flag-assert #x1c00c00140
|
|
(:methods
|
|
(judge-method-27 () none) ;; 27 ;; (setup-collision (_type_) none 27)
|
|
)
|
|
(:state-methods
|
|
wait ;; 26, old: (wait () _type_ :state 26)
|
|
enter ;; 20
|
|
idle ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern remote-track function) ;; (function none :behavior remote)
|
|
;; (define-extern cam-remote state) ;; (state camera-slave)
|
|
;; (define-extern voicebox-init-by-other function) ;; (function vector handle none :behavior voicebox)
|
|
;; (define-extern voicebox-spawn function) ;; (function process-drawable vector (pointer process))
|
|
;; (define-extern judge-init-by-other function) ;; (function vector uint none :behavior judge)
|
|
;; (define-extern judge-spawn function) ;; (function process-tree vector uint (pointer judge))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; idle-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype idle-control-frame (structure)
|
|
((command uint8 :offset-assert 0)
|
|
(anim uint32 :offset-assert 4)
|
|
(param0 int32 :offset-assert 8)
|
|
(param1 int32 :offset-assert 12)
|
|
(param2 basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
;; field param2 uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype idle-control (structure)
|
|
((anim (pointer idle-control-frame) :offset-assert 0) ;; guessed by decompiler
|
|
(anim-speed float :offset-assert 4)
|
|
(current-index int32 :offset-assert 8)
|
|
(counter int32 :offset-assert 12)
|
|
(target int32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x14
|
|
:flag-assert #xb00000014
|
|
(:methods
|
|
(idle-control-method-9 () none) ;; 9 ;; (idle-control-method-9 (_type_ (pointer idle-control-frame)) none 9)
|
|
(idle-control-method-10 () none) ;; 10 ;; (idle-control-method-10 (_type_ process-drawable) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tfrag ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype drawable-inline-array-tfrag (drawable-inline-array)
|
|
((length int16 :offset-assert 2)
|
|
(data tfragment :dynamic :offset-assert 32) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x64
|
|
:flag-assert #x1100000064
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *tfrag-display-stats* object) ;; symbol
|
|
;; (define-extern tfrag-vu1-block object) ;; vu-function
|
|
;; (define-extern tfrag-data-setup function) ;; (function tfrag-data int int none)
|
|
;; (define-extern add-tfrag-mtx-0 function) ;; (function dma-buffer symbol none)
|
|
;; (define-extern add-tfrag-mtx-1 function) ;; (function dma-buffer symbol none)
|
|
;; (define-extern add-tfrag-data function) ;; (function dma-buffer int int none)
|
|
;; (define-extern t-stat object) ;; tfrag-stats
|
|
;; (define-extern tfrag-print-stats function) ;; (function symbol none)
|
|
;; (define-extern tfrag-init-buffer function) ;; (function dma-buffer gs-test int symbol none)
|
|
;; (define-extern tfrag-end-buffer function) ;; (function dma-buffer int none)
|
|
;; (define-extern draw-inline-array-tfrag function) ;; (function pointer drawable-inline-array int dma-buffer none)
|
|
;; (define-extern tfrag-scissor-init-buffer function) ;; (function dma-buffer gs-test int symbol none)
|
|
;; (define-extern tfrag-scissor-end-buffer function) ;; (function dma-buffer uint none)
|
|
;; (define-extern draw-inline-array-tfrag-scissor function) ;; (function pointer drawable-inline-array int dma-buffer none)
|
|
;; (define-extern stats-tfrag-asm function) ;; (function tfragment none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tfrag-methods ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tfrag-init-data (structure)
|
|
((tfrag-bucket int32 :offset-assert 0) ;; bucket-id
|
|
(tfrag-scissor-bucket int32 :offset-assert 4) ;; bucket-id
|
|
(tfrag-trans-bucket int32 :offset-assert 8) ;; bucket-id
|
|
(tfrag-scissor-trans-bucket int32 :offset-assert 12) ;; bucket-id
|
|
(tfrag-water-bucket int32 :offset-assert 16) ;; bucket-id
|
|
(tfrag-water-scissor-bucket int32 :offset-assert 20) ;; bucket-id
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; (define-extern edge-debug-lines function) ;; (function (array vector-array) none)
|
|
;; (define-extern draw-drawable-tree-tfrag function) ;; (function drawable-tree-tfrag none)
|
|
;; (define-extern draw-drawable-tree-tfrag-trans function) ;; (function drawable-tree-tfrag none)
|
|
;; (define-extern draw-drawable-tree-tfrag-water function) ;; (function drawable-tree-tfrag none)
|
|
;; (define-extern tfrag-vu1-init-buf function) ;; (function bucket-id gs-test int uint symbol none)
|
|
;; (define-extern tfrag-scissor-vu1-init-buf function) ;; (function bucket-id gs-test int uint symbol none)
|
|
;; (define-extern *tfrag-init-table* object) ;; (inline-array tfrag-init-data)
|
|
;; (define-extern tfrag-vu1-init-buffers function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wlander-female ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype waster-b (civilian)
|
|
()
|
|
:method-count-assert 234
|
|
:size-assert #x464
|
|
:flag-assert #xea03f00464
|
|
(:state-methods
|
|
knocked ;; 31
|
|
get-up-front ;; 220
|
|
get-up-back ;; 221
|
|
wait ;; 190
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *waster-b-global-info* civilian-global-info)
|
|
;; (define-extern *waster-b-nav-enemy-info* nav-enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tfrag-work ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *tfrag-work* object) ;; tfrag-work
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pov-camera ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern pov-camera-play-and-reposition function) ;; (function art-joint-anim vector float none :behavior pov-camera)
|
|
;; (define-extern pov-camera-init-by-other function) ;; (function vector skeleton-group string pov-camera-flag process-drawable pair none :behavior pov-camera)
|
|
;; (define-extern othercam-calc function) ;; (function float float)
|
|
;; (define-extern othercam-init-by-other function) ;; (function pov-camera int symbol symbol none :behavior othercam)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; etie-near-vu1 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype etn-consts (structure)
|
|
((gifbufs qword :inline :offset-assert 0)
|
|
(adgif qword :inline :offset-assert 16)
|
|
(alpha qword :inline :offset-assert 32)
|
|
(strgif generic-gif-tag :inline :offset-assert 48)
|
|
(envgif generic-gif-tag :inline :offset-assert 64)
|
|
(envmap adgif-shader :inline :offset-assert 80)
|
|
(pers0 vector :inline :offset-assert 160)
|
|
(pers1 vector :inline :offset-assert 176)
|
|
(hvdf vector :inline :offset-assert 192)
|
|
(invh vector :inline :offset-assert 208)
|
|
(guard vector :inline :offset-assert 224)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf0
|
|
:flag-assert #x9000000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype etn-matrix (structure)
|
|
((rmtx matrix :inline :offset-assert 0)
|
|
(nmtx matrix3 :inline :offset-assert 64)
|
|
(morph float :offset-assert 76)
|
|
(fog float :offset-assert 92)
|
|
(fade uint32 :offset-assert 108)
|
|
(tint qword :inline :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype etn-vtx (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(clr vector :inline :offset-assert 16)
|
|
(tex vector :inline :offset-assert 32)
|
|
(tx2 vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype etn-plane (structure)
|
|
((point uint32 :offset-assert 0)
|
|
(prev uint32 :offset-assert 4)
|
|
(outfunc uint32 :offset-assert 8)
|
|
(flags uint32 :offset-assert 12)
|
|
(out etn-vtx :inline :offset-assert 16)
|
|
(in etn-vtx :inline :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
;; (define-extern etn-vu1-block object)
|
|
;; (define-extern etn-magic function)
|
|
;; (define-extern etn-init-consts function)
|
|
;; (define-extern etn-init-engine function) ;; (function dma-buffer none)
|
|
;; (define-extern etn-end-buffer function) ;; (function dma-buffer none)
|
|
;; (define-extern etn-float-reg-calc function)
|
|
;; (define-extern etn-float-reg function)
|
|
;; (define-extern etn-floats function)
|
|
;; (define-extern etn-int-reg-draw function)
|
|
;; (define-extern etn-int-reg function)
|
|
;; (define-extern etn-ints function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tie-near ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tie-near-consts (structure)
|
|
((extra qword :inline :offset-assert 0)
|
|
(gifbufs qword :inline :offset-assert 16)
|
|
(clrbufs qword :inline :offset-assert 32)
|
|
(adgif qword :inline :offset-assert 48)
|
|
(strgif qword :inline :offset-assert 64)
|
|
(fangif qword :inline :offset-assert 80)
|
|
(hvdfoffs vector :inline :offset-assert 96)
|
|
(invhscale vector :inline :offset-assert 112)
|
|
(guard vector :inline :offset-assert 128)
|
|
(atest UNKNOWN 2 :offset-assert 144)
|
|
(atest-tra gs-adcmd :inline :offset-assert 144)
|
|
(atest-def gs-adcmd :inline :offset-assert 160)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xb0
|
|
:flag-assert #x9000000b0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern tie-near-vu1-block object)
|
|
;; (define-extern tie-near-init-consts function)
|
|
;; (define-extern tie-near-init-engine function) ;; (function dma-buffer gs-test int none)
|
|
;; (define-extern tie-near-end-buffer function) ;; (function dma-buffer none)
|
|
;; (define-extern tie-scissor-make-perspective-matrix function) ;; (function matrix matrix none)
|
|
;; (define-extern tie-near-int-reg function)
|
|
;; (define-extern tie-near-float-reg function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flut-wild ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flut-wild (nav-enemy)
|
|
((minimap connection-minimap :offset-assert 620)
|
|
(focus-ignore-timer uint64 :offset-assert 624)
|
|
(color-index int32 :offset-assert 632)
|
|
(first-notice? basic :offset-assert 636)
|
|
)
|
|
:method-count-assert 192
|
|
:size-assert #x280
|
|
:flag-assert #xc002000280
|
|
(:state-methods
|
|
idle ;; 33
|
|
notice ;; 35
|
|
flee-path ;; 190
|
|
knocked ;; 31
|
|
disappear ;; 191
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-catch-flut (task-manager)
|
|
((flut-entity basic :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf4
|
|
:flag-assert #x20008000f4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-restrict-to-flut (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *flut-wild-enemy-info* nav-enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcano-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *vol-invis-joint-list* array)
|
|
;; (define-extern spt-birth-func-brightness-part-volcano-rock-break-dust function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mantis ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mantis-jump-info (structure)
|
|
((distance float :offset-assert 0)
|
|
(search-step uint32 :offset-assert 4)
|
|
(destination vector :inline :offset-assert 16)
|
|
(direction uint16 :offset-assert 32)
|
|
(start-anim uint32 :offset-assert 36)
|
|
(air-anim uint32 :offset-assert 40)
|
|
(land-anim uint32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mantis (nav-enemy)
|
|
((base-height float :offset-assert 616)
|
|
(flags mantis-flag :offset-assert 620)
|
|
(attack-timer uint64 :offset-assert 628) ;; time-frame
|
|
(track-timer uint64 :offset-assert 636) ;; time-frame
|
|
(gspot-timer uint64 :offset-assert 644) ;; time-frame
|
|
(gspot-normal vector :inline :offset-assert 652)
|
|
(my-up-vector vector :inline :offset-assert 668)
|
|
(jump mantis-jump-info :inline :offset-assert 684)
|
|
)
|
|
:method-count-assert 207
|
|
:size-assert #x2e0
|
|
:flag-assert #xcf026002e0
|
|
;; field mantis-flag is likely a value type.
|
|
(:methods
|
|
(mantis-method-195 () none) ;; 195
|
|
(mantis-method-199 () none) ;; 199
|
|
(mantis-method-200 () none) ;; 200
|
|
(mantis-method-201 () none) ;; 201
|
|
(mantis-method-202 () none) ;; 202
|
|
(mantis-method-203 () none) ;; 203
|
|
(mantis-method-204 () none) ;; 204
|
|
(mantis-method-205 () none) ;; 205
|
|
(mantis-method-206 () none) ;; 206
|
|
)
|
|
(:state-methods
|
|
ambush-jumping ;; 194, old: (mantis-method-194 (_type_) symbol 194)
|
|
active ;; 34
|
|
attack0 ;; 191, old: (mantis-method-191 (_type_ vector vector) int 191)
|
|
ambush ;; 47
|
|
ambush-crawling ;; 193, old: (mantis-method-193 (_type_ vector) none 193)
|
|
crawl ;; 190, old: (mantis-method-190 (_type_ vector vector) none 190)
|
|
hostile ;; 38
|
|
attack1 ;; 192, old: (mantis-method-192 (_type_ vector vector) none 192)
|
|
roll-right ;; 196
|
|
roll-left ;; 197
|
|
hop-away ;; 198
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-mantis-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *mantis-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern mantis-roll-post function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hvehicle-physics ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tie-work ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *instance-tie-work* object) ;; instance-tie-work
|
|
;; (define-extern *prototype-tie-work* object) ;; prototype-tie-work
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tie-methods ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tie-debug (structure)
|
|
((max-instance uint32 :offset-assert 0)
|
|
(min-instance uint32 :offset-assert 4)
|
|
(test-fragment uint32 :offset-assert 8)
|
|
(frag-count uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tie-init-data (structure)
|
|
((tie-bucket int32 :offset-assert 0) ;; bucket-id
|
|
(tie-scissor-bucket int32 :offset-assert 4) ;; bucket-id
|
|
(tie-envmap-bucket int32 :offset-assert 8) ;; bucket-id
|
|
(tie-envmap-scissor-bucket int32 :offset-assert 12) ;; bucket-id
|
|
(tie-vanish-bucket int32 :offset-assert 16) ;; bucket-id
|
|
(tie-trans-bucket int32 :offset-assert 20) ;; bucket-id
|
|
(tie-scissor-trans-bucket int32 :offset-assert 24) ;; bucket-id
|
|
(tie-envmap-trans-bucket int32 :offset-assert 28) ;; bucket-id
|
|
(tie-envmap-scissor-trans-bucket int32 :offset-assert 32) ;; bucket-id
|
|
(tie-water-bucket int32 :offset-assert 36) ;; bucket-id
|
|
(tie-scissor-water-bucket int32 :offset-assert 40) ;; bucket-id
|
|
(tie-envmap-water-bucket int32 :offset-assert 44) ;; bucket-id
|
|
(tie-envmap-scissor-water-bucket int32 :offset-assert 48) ;; bucket-id
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *tie* object) ;; tie-debug
|
|
;; (define-extern tie-debug-between function) ;; (function uint uint uint)
|
|
;; (define-extern tie-debug-one function) ;; (function uint uint uint)
|
|
;; (define-extern tie-debug-frag-between function) ;; (function uint uint uint)
|
|
;; (define-extern tie-debug-frag-one function) ;; (function uint uint uint)
|
|
;; (define-extern walk-tie-generic-prototypes function) ;; (function none)
|
|
;; (define-extern *pke-hack* object) ;; vector
|
|
;; (define-extern draw-inline-array-instance-tie function) ;; (function pointer (inline-array instance-tie) int dma-buffer none)
|
|
;; (define-extern draw-inline-array-prototype-tie-asm function) ;; (function dma-buffer int prototype-array-tie none)
|
|
;; (define-extern instance-tie-patch-buckets function) ;; (function dma-buffer level object)
|
|
;; (define-extern draw-drawable-tree-instance-tie function) ;; (function drawable-tree-instance-tie level none)
|
|
;; (define-extern tie-init-scissor-buf function) ;; (function bucket-id gs-alpha gs-test gs-test none)
|
|
;; (define-extern tie-init-buf function) ;; (function bucket-id gs-alpha gs-test gs-test none)
|
|
;; (define-extern tie-init-envmap-buf function) ;; (function bucket-id gs-alpha gs-test none)
|
|
;; (define-extern tie-init-envmap-scissor-buf function) ;; (function bucket-id gs-alpha int int none)
|
|
;; (define-extern *tie-init-table* object) ;; (inline-array tie-init-data)
|
|
;; (define-extern tie-vu1-init-buffers function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; menu ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype debug-menu-context (basic)
|
|
((is-active symbol :offset-assert 4) ;; guessed by decompiler
|
|
(sel-length int32 :offset-assert 8)
|
|
(sel-menu debug-menu 8 :offset-assert 12) ;; guessed by decompiler
|
|
(root-menu debug-menu :offset-assert 44) ;; guessed by decompiler
|
|
(joypad-func (function basic int none) :offset-assert 48) ;; guessed by decompiler
|
|
(joypad-item basic :offset-assert 52)
|
|
(font font-context :offset-assert 56) ;; guessed by decompiler
|
|
(is-hidden symbol :offset-assert 60) ;; guessed by decompiler
|
|
(joypad-number int32 :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-menu-node (basic)
|
|
((name string :offset-assert 4) ;; guessed by decompiler
|
|
(parent debug-menu :offset-assert 8) ;; guessed by decompiler
|
|
(refresh-delay int32 :offset-assert 12)
|
|
(refresh-ctr int32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-menu (debug-menu-node)
|
|
((context debug-menu-context :offset-assert 20) ;; guessed by decompiler
|
|
(selected-item debug-menu-item :offset-assert 24) ;; guessed by decompiler
|
|
(pix-width int32 :offset-assert 28)
|
|
(pix-height int32 :offset-assert 32)
|
|
(items pair :offset-assert 36) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-menu-item (debug-menu-node)
|
|
((id int32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-menu-item-submenu (debug-menu-item)
|
|
((submenu debug-menu :offset-assert 24) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-menu-item-function (debug-menu-item)
|
|
((activate-func (function object object) :offset-assert 24) ;; guessed by decompiler
|
|
(hilite-timer int8 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1d
|
|
:flag-assert #x90000001d
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-menu-item-flag (debug-menu-item)
|
|
((activate-func (function object debug-menu-msg object) :offset-assert 24) ;; guessed by decompiler
|
|
(is-on object :offset-assert 28) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debug-menu-item-var (debug-menu-item)
|
|
((display-str string :offset-assert 24) ;; guessed by decompiler
|
|
(grabbed-joypad-p symbol :offset-assert 28) ;; guessed by decompiler
|
|
(float-p symbol :offset-assert 32) ;; guessed by decompiler
|
|
(range-p symbol :offset-assert 36) ;; guessed by decompiler
|
|
(show-len int32 :offset-assert 40)
|
|
(inc-delay int32 :offset-assert 44)
|
|
(inc-delay-ctr int32 :offset-assert 48)
|
|
(step-delay-ctr int32 :offset-assert 52)
|
|
(inc-dir int32 :offset-assert 56)
|
|
(fval float :offset-assert 60)
|
|
(fundo-val float :offset-assert 64)
|
|
(frange-min float :offset-assert 68)
|
|
(frange-max float :offset-assert 72)
|
|
(fstart-inc float :offset-assert 76)
|
|
(fstep float :offset-assert 80)
|
|
(fprecision int32 :offset-assert 84)
|
|
(factivate-func (function int debug-menu-msg float float float) :offset-assert 88) ;; guessed by decompiler
|
|
(ival int32 :offset-assert 60)
|
|
(iundo-val int32 :offset-assert 64)
|
|
(irange-min int32 :offset-assert 68)
|
|
(irange-max int32 :offset-assert 72)
|
|
(istart-inc int32 :offset-assert 76)
|
|
(istep int32 :offset-assert 80)
|
|
(ihex-p symbol :offset-assert 92) ;; guessed by decompiler
|
|
(iactivate-func (function int debug-menu-msg int int int) :offset-assert 88) ;; guessed by decompiler
|
|
(ifloat-p symbol :offset-assert 96) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x64
|
|
:flag-assert #x900000064
|
|
)
|
|
|#
|
|
|
|
;; (define-extern debug-menu-item-var-update-display-str function) ;; (function debug-menu-item-var debug-menu-item-var)
|
|
;; (define-extern debug-menu-item-var-make-int function) ;; (function debug-menu-item-var (function int debug-menu-msg int int int) int symbol int int symbol debug-menu-item-var)
|
|
;; (define-extern debug-menu-item-var-make-float function) ;; (function debug-menu-item-var (function int debug-menu-msg float float float) float symbol float float int debug-menu-item-var)
|
|
;; (define-extern debug-menu-context-grab-joypad function) ;; (function debug-menu-context basic (function basic int none) symbol)
|
|
;; (define-extern debug-menu-context-release-joypad function) ;; (function debug-menu-context symbol)
|
|
;; (define-extern debug-menu-item-get-max-width function) ;; (function debug-menu-item debug-menu int)
|
|
;; (define-extern debug-menu-context-default-selection function) ;; (function debug-menu-context symbol debug-menu-context)
|
|
;; (define-extern debug-menu-rebuild function) ;; (function debug-menu debug-menu)
|
|
;; (define-extern debug-menu-context-set-root-menu function) ;; (function debug-menu-context debug-menu debug-menu-context)
|
|
;; (define-extern debug-menu-append-item function) ;; (function debug-menu debug-menu-node debug-menu-node)
|
|
;; (define-extern debug-menu-remove-all-items function) ;; (function debug-menu debug-menu)
|
|
;; (define-extern debug-menu-func-decode function) ;; (function object function)
|
|
;; (define-extern debug-menu-make-from-template function) ;; (function debug-menu-context pair debug-menu-node)
|
|
;; (define-extern debug-menu-find-from-template function) ;; (function debug-menu-context pair debug-menu)
|
|
;; (define-extern debug-menu-item-submenu-render function) ;; (function debug-menu-item-submenu int int int symbol debug-menu-item-submenu)
|
|
;; (define-extern debug-menu-item-function-render function) ;; (function debug-menu-item-function int int int symbol debug-menu-item-function)
|
|
;; (define-extern debug-menu-item-flag-render function) ;; (function debug-menu-item-flag int int int symbol debug-menu-item-flag)
|
|
;; (define-extern debug-menu-item-var-render function) ;; (function debug-menu-item-var int int int symbol debug-menu-item-var)
|
|
;; (define-extern debug-menu-item-render function) ;; (function debug-menu-item int int int symbol debug-menu-item)
|
|
;; (define-extern debug-menu-render function) ;; (function debug-menu int int debug-menu-node int debug-menu)
|
|
;; (define-extern debug-menu-context-render function) ;; (function debug-menu-context debug-menu-context)
|
|
;; (define-extern debug-menu-context-select-next-or-prev-item function) ;; (function debug-menu-context int debug-menu-context)
|
|
;; (define-extern debug-menu-context-select-new-item function) ;; (function debug-menu-context int debug-menu-context)
|
|
;; (define-extern debug-menu-context-open-submenu function) ;; (function debug-menu-context debug-menu basic)
|
|
;; (define-extern debug-menu-context-close-submenu function) ;; (function debug-menu-context debug-menu-context)
|
|
;; (define-extern debug-menu-item-submenu-msg function) ;; (function debug-menu-item-submenu debug-menu-msg debug-menu-item-submenu)
|
|
;; (define-extern debug-menu-item-function-msg function) ;; (function debug-menu-item-function debug-menu-msg debug-menu-item-function)
|
|
;; (define-extern debug-menu-item-flag-msg function) ;; (function debug-menu-item-flag debug-menu-msg debug-menu-item-flag)
|
|
;; (define-extern debug-menu-item-var-joypad-handler function) ;; (function debug-menu-item-var int debug-menu-item-var)
|
|
;; (define-extern debug-menu-item-var-msg function) ;; (function debug-menu-item-var debug-menu-msg debug-menu-item-var)
|
|
;; (define-extern debug-menu-item-send-msg function) ;; (function debug-menu-item debug-menu-msg debug-menu-item)
|
|
;; (define-extern debug-menu-send-msg function) ;; (function debug-menu debug-menu-msg symbol debug-menu)
|
|
;; (define-extern debug-menu-context-send-msg function) ;; (function debug-menu-context debug-menu-msg debug-menu-dest debug-menu-context)
|
|
;; (define-extern debug-menu-context-activate-selection function) ;; (function debug-menu-context debug-menu-context)
|
|
;; (define-extern debug-menus-default-joypad-func function) ;; (function debug-menu-context debug-menu-context)
|
|
;; (define-extern debug-menus-active function) ;; (function debug-menu-context debug-menu-context)
|
|
;; (define-extern debug-menus-handler function) ;; (function debug-menu-context debug-menu-context)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; assault-enemies ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype assault-object-spawn-params (traffic-object-spawn-params)
|
|
((nav-branch nav-branch :offset-assert 24)
|
|
(lev basic :offset-assert 116)
|
|
(suck-level int32 :offset-assert 120)
|
|
(flee-time uint64 :offset-assert 128)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x88
|
|
:flag-assert #x900000088
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-metalhead-grunt (metalhead-grunt)
|
|
()
|
|
:method-count-assert 232
|
|
:size-assert #x480
|
|
:flag-assert #xe804000480
|
|
(:state-methods
|
|
exit-transport ;; 231
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-metalhead-flitter (metalhead-flitter)
|
|
()
|
|
:method-count-assert 230
|
|
:size-assert #x494
|
|
:flag-assert #xe604200494
|
|
(:state-methods
|
|
exit-transport ;; 229
|
|
in-ditch ;; 192
|
|
die-fast ;; 42
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-metalhead-predator (metalhead-predator)
|
|
()
|
|
:method-count-assert 228
|
|
:size-assert #x550
|
|
:flag-assert #xe404d00550
|
|
(:state-methods
|
|
in-ditch ;; 192
|
|
die-fast ;; 42
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-roboguard (roboguard-city)
|
|
((shoot-wait-time uint64 :offset-assert 1600)
|
|
)
|
|
:method-count-assert 242
|
|
:size-assert #x648
|
|
:flag-assert #xf205d00648
|
|
(:state-methods
|
|
hostile-stand ;; 222
|
|
shoot-attack ;; 224
|
|
in-ditch ;; 192
|
|
roll-initial ;; 241
|
|
die-fast ;; 42
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-spydroid (spydroid)
|
|
()
|
|
:method-count-assert 238
|
|
:size-assert #x50c
|
|
:flag-assert #xee0490050c
|
|
(:state-methods
|
|
in-ditch ;; 192
|
|
die-fast ;; 42
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-flying-turret (flying-turret)
|
|
()
|
|
:method-count-assert 231
|
|
:size-assert #x568
|
|
:flag-assert #xe704f00568
|
|
(:state-methods
|
|
in-ditch ;; 192
|
|
die-fast ;; 42
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-crimson-guard (crimson-guard)
|
|
((center-pos vector :inline :offset-assert 1616)
|
|
)
|
|
:method-count-assert 292
|
|
:size-assert #x660
|
|
:flag-assert #x12405e00660
|
|
(:state-methods
|
|
in-ditch ;; 192
|
|
die-fast ;; 42
|
|
active ;; 34
|
|
wait-for-enemies ;; 291
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-citizen-norm (citizen-norm)
|
|
((center-pos vector :inline :offset-assert 1136)
|
|
(min-flee-time uint64 :offset-assert 1152)
|
|
)
|
|
:method-count-assert 237
|
|
:size-assert #x488
|
|
:flag-assert #xed04100488
|
|
(:state-methods
|
|
knocked-recover ;; 32
|
|
flee-to-center ;; 236
|
|
flee-madly ;; 235
|
|
cower-ground ;; 222
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-cleanup (process)
|
|
((offscreen-time uint64 :offset-assert 128)
|
|
(parent-hand uint64 :offset-assert 136)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x90
|
|
:flag-assert #xf00100090
|
|
(:state-methods
|
|
tracking ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype special-health (health)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x194
|
|
:flag-assert #x2401200194
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ammo-special-pickup (process-focusable)
|
|
((ammo-type int32 :offset-assert 208)
|
|
(gun-type int32 :offset-assert 212)
|
|
(collect-effect basic :offset-assert 216)
|
|
(ammo-effect basic :offset-assert 220)
|
|
(anim-index int32 :offset-assert 224)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #xe4
|
|
:flag-assert #x1f007000e4
|
|
(:methods
|
|
(ammo-special-pickup-method-30 () none) ;; 30
|
|
)
|
|
(:state-methods
|
|
wait ;; 28
|
|
pickup ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-bombbot (bombbot)
|
|
((next-node int32 :offset-assert 1512)
|
|
(new-point-choose-time uint64 :offset-assert 1520)
|
|
(max-hp float :offset-assert 1532)
|
|
(is-final? basic :offset-assert 1536)
|
|
(last-charge-player-count uint32 :offset-assert 1540)
|
|
(suck-level int32 :offset-assert 1544)
|
|
)
|
|
:method-count-assert 210
|
|
:size-assert #x60c
|
|
:flag-assert #xd20590060c
|
|
(:methods
|
|
(assault-bombbot-method-209 () none) ;; 209
|
|
)
|
|
(:state-methods
|
|
explode ;; 190
|
|
hostile ;; 38
|
|
drop-bombs ;; 193
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-bombbot-spawn-params (bombbot-spawn-params)
|
|
((is-final? basic :offset-assert 48)
|
|
(suck-level int32 :offset-assert 52)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-bombbot-shot (bombbot-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
;; (define-extern assault-enemy-init-by-other function)
|
|
;; (define-extern assault-type->type function)
|
|
;; (define-extern assault-cleanup-init-by-other function)
|
|
;; (define-extern *assault-levels* array)
|
|
;; (define-extern spawn-assault-enemy function)
|
|
;; (define-extern special-health-init-by-other function)
|
|
;; (define-extern ammo-special-pickup-init-by-other function)
|
|
;; (define-extern assault-bombbot-init-by-other function)
|
|
;; (define-extern *curve-assault-bombbot-shot-color-blue* curve-color-fast)
|
|
;; (define-extern *curve-assault-bombbot-shot-width* curve2d-fast)
|
|
;; (define-extern *assault-bombbot-trail* object)
|
|
;; (define-extern *assault-bombbot-trail-2* object)
|
|
;; (define-extern *bombbot-bomb-hp-thresholds* array)
|
|
;; (define-extern *look-time* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern sparticle-torch-spline-align function)
|
|
;; (define-extern spt-func-fact-torch function)
|
|
;; (define-extern spt-birth-func-fact-torch function)
|
|
;; (define-extern *range-color-fact-big-torch-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-fact-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-fact-big-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-fact-big-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-fact-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-fact-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-fact-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-fact-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-fact-big-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-fact-big-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *part-fact-big-torch-flame-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; neo-satellite ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype neo-sat-laser-info (structure)
|
|
((joint int16 :offset-assert 0)
|
|
(rope-index int16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-sat-hash-index (structure)
|
|
((h0 float :offset-assert 0)
|
|
(h1 float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-neo-sat-whip (rope-prim-system)
|
|
((parent-handle uint64 :offset-assert 104)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x70
|
|
:flag-assert #x1900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-sat-yellow-ammo-pos (structure)
|
|
((angle float :offset-assert 0)
|
|
(dist float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-sat (nav-enemy)
|
|
((nav-vector vector :inline :offset-assert 624)
|
|
(y-movement float :offset-assert 640)
|
|
(ground-offset float :offset-assert 644)
|
|
(desired-y-height float :offset-assert 648)
|
|
(xz-vel float :offset-assert 652)
|
|
(x-vel float :offset-assert 656)
|
|
(z-vel float :offset-assert 660)
|
|
(offset-angle float :offset-assert 664)
|
|
(last-thrust-vec vector :inline :offset-assert 672)
|
|
(disc-joint joint-mod-rotate-local :inline :offset-assert 688)
|
|
(laser-rotate-angle float :offset-assert 720)
|
|
(wander-generate-time uint64 :offset-assert 728)
|
|
(hit-player? basic :offset-assert 736)
|
|
(desired-float-height float :offset-assert 740)
|
|
(bob-speed-scalar float :offset-assert 744)
|
|
(on-ground? basic :offset-assert 748)
|
|
(current-shockwave-radius float :offset-assert 752)
|
|
(active-laser-index int8 :offset-assert 756)
|
|
(current-stage int8 :offset-assert 757)
|
|
(fly-speed-scalar float :offset-assert 760)
|
|
(last-shockwave-radius float :offset-assert 764)
|
|
(ropes basic :offset-assert 768)
|
|
(max-speed float :offset-assert 772)
|
|
(spin-current float :offset-assert 776)
|
|
(spin-dest float :offset-assert 780)
|
|
(spin-speed float :offset-assert 784)
|
|
(hashed-heights UNKNOWN 1225 :offset-assert 788)
|
|
(shockwave-origin vector :inline :offset-assert 5696)
|
|
(current-height-probe-index int16 :offset-assert 5712)
|
|
(last-spawned-ring-index int16 :offset-assert 5714)
|
|
(global-neo-sat-index uint8 :offset-assert 5716)
|
|
(yellow-ammo-pos UNKNOWN 4 :offset-assert 5720)
|
|
(num-yellow-ammo int8 :offset-assert 5784)
|
|
(start-thrust-pos vector :inline :offset-assert 5792)
|
|
(was-player-inside-cone? basic :offset-assert 5808)
|
|
(was-doing-cone-check? basic :offset-assert 5812)
|
|
(damage-part1 basic :offset-assert 5816)
|
|
(damage-part2 basic :offset-assert 5820)
|
|
(damage-part3 basic :offset-assert 5824)
|
|
(burst-dust-part basic :offset-assert 5828)
|
|
(warp-handle uint64 :offset-assert 5832)
|
|
(spine-joint-mods UNKNOWN 6 :offset-assert 5840)
|
|
(actual-laser-rotate-angle float :offset-assert 6032)
|
|
(last-particle-rotate float :offset-assert 6036)
|
|
(trunk-joint joint-mod-rotate-local :inline :offset-assert 6048)
|
|
(ground-height float :offset-assert 6080)
|
|
(tentacle basic :offset-assert 6084)
|
|
(anim-loop? basic :offset-assert 6088)
|
|
(play-anim? basic :offset-assert 6092)
|
|
(anim-speed float :offset-assert 6096)
|
|
(should-rise? basic :offset-assert 6100)
|
|
(last-play-laser-time uint64 :offset-assert 6104)
|
|
(snd-laser-burn uint32 :offset-assert 6112)
|
|
(snd-whips-loop UNKNOWN 3 :offset-assert 6116)
|
|
(sound-last-snap-time UNKNOWN 3 :offset-assert 6128)
|
|
(sound-next-play-time UNKNOWN 3 :offset-assert 6152)
|
|
(new-spin-time uint64 :offset-assert 6176)
|
|
(snd-arms-chatter uint32 :offset-assert 6184)
|
|
(was-spinning? basic :offset-assert 6188)
|
|
(snd-hover uint32 :offset-assert 6192)
|
|
(snd-spool-explosion uint32 :offset-assert 6196)
|
|
(antenna-explode-part basic :offset-assert 6200)
|
|
(next-lightning-time uint64 :offset-assert 6208)
|
|
)
|
|
:method-count-assert 234
|
|
:size-assert #x1848
|
|
:flag-assert #xea17d01848
|
|
(:methods
|
|
(neo-sat-method-198 () none) ;; 198
|
|
(neo-sat-method-199 () none) ;; 199
|
|
(neo-sat-method-200 () none) ;; 200
|
|
(neo-sat-method-201 () none) ;; 201
|
|
(neo-sat-method-202 () none) ;; 202
|
|
(neo-sat-method-203 () none) ;; 203
|
|
(neo-sat-method-204 () none) ;; 204
|
|
(neo-sat-method-205 () none) ;; 205
|
|
(neo-sat-method-206 () none) ;; 206
|
|
(neo-sat-method-207 () none) ;; 207
|
|
(neo-sat-method-208 () none) ;; 208
|
|
(neo-sat-method-209 () none) ;; 209
|
|
(neo-sat-method-210 () none) ;; 210
|
|
(neo-sat-method-211 () none) ;; 211
|
|
(neo-sat-method-212 () none) ;; 212
|
|
(neo-sat-method-213 () none) ;; 213
|
|
(neo-sat-method-214 () none) ;; 214
|
|
(neo-sat-method-215 () none) ;; 215
|
|
(neo-sat-method-216 () none) ;; 216
|
|
(neo-sat-method-217 () none) ;; 217
|
|
(neo-sat-method-218 () none) ;; 218
|
|
(neo-sat-method-219 () none) ;; 219
|
|
(neo-sat-method-220 () none) ;; 220
|
|
(neo-sat-method-221 () none) ;; 221
|
|
(neo-sat-method-222 () none) ;; 222
|
|
(neo-sat-method-223 () none) ;; 223
|
|
(neo-sat-method-224 () none) ;; 224
|
|
(neo-sat-method-225 () none) ;; 225
|
|
(neo-sat-method-226 () none) ;; 226
|
|
(neo-sat-method-227 () none) ;; 227
|
|
(neo-sat-method-228 () none) ;; 228
|
|
(neo-sat-method-229 () none) ;; 229
|
|
(neo-sat-method-230 () none) ;; 230
|
|
(neo-sat-method-231 () none) ;; 231
|
|
(neo-sat-method-232 () none) ;; 232
|
|
(neo-sat-method-233 () none) ;; 233
|
|
)
|
|
(:state-methods
|
|
neo-sat-drill-returning ;; 193
|
|
die ;; 40
|
|
neo-sat-drill-prepare ;; 192
|
|
neo-sat-sit-and-spin ;; 196
|
|
neo-sat-drill-impact ;; 195
|
|
neo-sat-drill-attack ;; 191
|
|
neo-sat-laser-attack ;; 194
|
|
ground-burst ;; 197
|
|
hostile ;; 38
|
|
sat-idle ;; 190
|
|
)
|
|
(:states
|
|
neo-sat-drill-halting
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-sat-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-sat-shield (process-drawable)
|
|
()
|
|
:method-count-assert 26
|
|
:size-assert #xc8
|
|
:flag-assert #x1a005000c8
|
|
(:methods
|
|
(neo-sat-shield-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
hit ;; 23
|
|
turning-off ;; 22
|
|
turning-on ;; 21
|
|
disabled ;; 24
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spt-birth-func-brightness-sat-shockwave function)
|
|
;; (define-extern spt-birth-func-part-sat-shockwave function)
|
|
;; (define-extern spt-birth-func-brightness-scorch-bits function)
|
|
;; (define-extern spt-birth-func-part-scorch-bits function)
|
|
;; (define-extern spt-birth-func-part-ground-impact function)
|
|
;; (define-extern spt-birth-func-part-ground-emerge function)
|
|
;; (define-extern *range-sat-explo-color* curve-color-fast)
|
|
;; (define-extern *range-sat-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-sat-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-sat-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-neo-satellite-explosion-texture-curve-settings* object)
|
|
;; (define-extern *neo-sat-laser-array* array)
|
|
;; (define-extern *neo-sat-focus-pos* object)
|
|
;; (define-extern *alive-neo-sats* array)
|
|
;; (define-extern *neo-sat-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern *neo-sat-rope-tentacle* object)
|
|
;; (define-extern *neo-satellite-nav-mesh* object)
|
|
;; (define-extern neo-sat-init-by-other function)
|
|
;; (define-extern *h0* object)
|
|
;; (define-extern *h1* object)
|
|
;; (define-extern *hs* object)
|
|
;; (define-extern *m0* object)
|
|
;; (define-extern *m1* object)
|
|
;; (define-extern *ms* object)
|
|
;; (define-extern *move-offset* object)
|
|
;; (define-extern *maxh* object)
|
|
;; (define-extern *minh* object)
|
|
;; (define-extern *maxl* object)
|
|
;; (define-extern *minl* object)
|
|
;; (define-extern sparticle-height-set function)
|
|
;; (define-extern spt-func-part-neo-sat-shockwave-hot function)
|
|
;; (define-extern sparticle-shockwave-set function)
|
|
;; (define-extern spawn-neo-sat function)
|
|
;; (define-extern compute-xz-pos function)
|
|
;; (define-extern neo-sat-inside-cone? function)
|
|
;; (define-extern neo-sat-shield-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyport-attack ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype port-attack-speech-instance (speech-instance)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyport-mine-layout (structure)
|
|
((mine-type uint64 :offset-assert 0)
|
|
(num-mines int8 :offset-assert 8)
|
|
(inout? basic :offset-assert 12)
|
|
(spin? basic :offset-assert 16)
|
|
(active? basic :offset-assert 20)
|
|
(checked-this-frame? basic :offset-assert 24)
|
|
(origin vector :inline :offset-assert 32)
|
|
(secondary-pos vector :inline :offset-assert 48)
|
|
(initial-angle float :offset-assert 64)
|
|
(spacing float :offset-assert 68)
|
|
(spinrate float :offset-assert 72)
|
|
(period float :offset-assert 76)
|
|
(offset float :offset-assert 80)
|
|
(stored-handles uint32 :offset-assert 84)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x58
|
|
:flag-assert #x900000058
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyport-attack-package-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(locked? basic :offset-assert 16)
|
|
(on-water? basic :offset-assert 20)
|
|
(probe? basic :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyport-attack-hud (hud)
|
|
((pos-tt float :offset-assert 2756)
|
|
(tt-current float :offset-assert 2760)
|
|
(tt-prev float :offset-assert 2764)
|
|
(tt-next float :offset-assert 2768)
|
|
(spike-time uint64 :offset-assert 2776)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xae0
|
|
:flag-assert #x1b0a600ae0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyport-attack-manager (task-manager)
|
|
((active-torpedo uint64 :offset-assert 240)
|
|
(inactive-mine-list basic :offset-assert 248)
|
|
(mine-clock uint64 :offset-assert 256)
|
|
(current-package-index int16 :offset-assert 264)
|
|
(rod-of-god uint64 :offset-assert 272)
|
|
(wall-h uint64 :offset-assert 280)
|
|
(passed-cutscene-trigger? basic :offset-assert 288)
|
|
(finish-type basic :offset-assert 292)
|
|
(mine-layout basic :offset-assert 296)
|
|
(package-positions basic :offset-assert 300)
|
|
(h-hud uint64 :offset-assert 304)
|
|
)
|
|
:method-count-assert 52
|
|
:size-assert #x138
|
|
:flag-assert #x3400c00138
|
|
(:methods
|
|
(ctyport-attack-manager-method-34 () none) ;; 34
|
|
(ctyport-attack-manager-method-42 () none) ;; 42
|
|
(ctyport-attack-manager-method-43 () none) ;; 43
|
|
(ctyport-attack-manager-method-44 () none) ;; 44
|
|
(ctyport-attack-manager-method-45 () none) ;; 45
|
|
(ctyport-attack-manager-method-46 () none) ;; 46
|
|
(ctyport-attack-manager-method-47 () none) ;; 47
|
|
(ctyport-attack-manager-method-48 () none) ;; 48
|
|
(ctyport-attack-manager-method-49 () none) ;; 49
|
|
(ctyport-attack-manager-method-50 () none) ;; 50
|
|
(ctyport-attack-manager-method-51 () none) ;; 51
|
|
)
|
|
(:state-methods
|
|
start-mission ;; 38
|
|
wait ;; 14
|
|
wait-for-cleanup ;; 37
|
|
nuke-wall ;; 36
|
|
watch-approach ;; 35
|
|
head-to-wall ;; 33
|
|
exit-naughty-ottsel ;; 40
|
|
pickup-nukes ;; 32
|
|
get-on-nuke ;; 39
|
|
play-get-on-movie ;; 41
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyport-mine (process-drawable)
|
|
((bob-scalar float :offset-assert 200)
|
|
(last-play-time uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xd8
|
|
:flag-assert #x18006000d8
|
|
(:methods
|
|
(ctyport-mine-method-23 () none) ;; 23 ;; (ctyport-mine-method-23 (_type_) none 23)
|
|
)
|
|
(:state-methods
|
|
hidden ;; 20, old: (idle () _type_ :state 20)
|
|
idle ;; 21, old: (die () _type_ :state 21)
|
|
menacing ;; 22, old: (fall () _type_ :state 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyport-attack-package (process-drawable)
|
|
((hum-sound uint32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-dax-missile-launcher (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ctyport-attack-speech-list* object)
|
|
;; (define-extern *port-attack-speech* array)
|
|
;; (define-extern *port-attack-dead-pool* object)
|
|
;; (define-extern ctyport-attack-manager-event-handler function)
|
|
;; (define-extern classify-mine-layout function)
|
|
;; (define-extern *recorded-pos* object)
|
|
;; (define-extern *recorded-length* object)
|
|
;; (define-extern record-pos function)
|
|
;; (define-extern print-record-pos function)
|
|
;; (define-extern *ctyport-mine-positions* array)
|
|
;; (define-extern *ctyport-package-positions* array)
|
|
;; (define-extern *ctyport-barrier-pos* object)
|
|
;; (define-extern get-ctyport-attack-death-count function)
|
|
;; (define-extern ctyport-mine-init-by-other function) ;; (function city-port-run-mine-info none :behavior ctyport-mine)
|
|
;; (define-extern ctyport-attack-package-init-by-other function)
|
|
;; (define-extern ctyport-attack-setup function)
|
|
;; (define-extern *cutscene-trigger-plane-normal* object)
|
|
;; (define-extern *cutscene-trigger-plane-pt* object)
|
|
;; (define-extern *approach-camera-pt* object)
|
|
;; (define-extern *approach-camera-matrix* object)
|
|
;; (define-extern *port-attack-fail-sphere* object)
|
|
;; (define-extern *port-attack-fail-radius* object)
|
|
;; (define-extern copy-record-pos function)
|
|
;; (define-extern print-record-pos-2 function)
|
|
;; (define-extern lctypatk-login function)
|
|
;; (define-extern lctypatk-logout function)
|
|
;; (define-extern *hud-boost-curve* curve2d-fast)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; guard-rifle ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sync-info ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cam-eye-bank (basic)
|
|
((rot-speed float :offset-assert 4)
|
|
(max-degrees float :offset-assert 8)
|
|
(max-fov float :offset-assert 12)
|
|
(min-fov float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-string-bank (basic)
|
|
((los-coll-rad meters :offset-assert 4)
|
|
(los-coll-rad2 meters :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype los-dist (structure)
|
|
((par-dist float :offset-assert 0)
|
|
(lat-dist float :offset-assert 4)
|
|
(vert-dist float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-los-dist-info (structure)
|
|
((min-par float :offset-assert 0)
|
|
(max-par float :offset-assert 4)
|
|
(min-lat float :offset-assert 8)
|
|
(max-lat float :offset-assert 12)
|
|
(min-vp float :offset-assert 16)
|
|
(max-vp float :offset-assert 20)
|
|
(min-vn float :offset-assert 24)
|
|
(max-vn float :offset-assert 28)
|
|
(count int32 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-los-result (structure)
|
|
((lateral vector :inline :offset-assert 0)
|
|
(cw collide-los-dist-info :inline :offset-assert 16)
|
|
(ccw collide-los-dist-info :inline :offset-assert 64)
|
|
(straddle collide-los-dist-info :inline :offset-assert 112)
|
|
(lateral-valid symbol :offset-assert 148) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x98
|
|
:flag-assert #x900000098
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-stick-bank (basic)
|
|
((max-z meters :offset-assert 4)
|
|
(min-z meters :offset-assert 8)
|
|
(max-y meters :offset-assert 12)
|
|
(min-y meters :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-bike-bank (basic)
|
|
((min-z meters :offset-assert 4)
|
|
(max-z meters :offset-assert 8)
|
|
(min-y meters :offset-assert 12)
|
|
(max-y meters :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
;; (define-extern cam-no-trans state)
|
|
;; (define-extern cam-really-fixed state) ;; (state camera-slave)
|
|
;; (define-extern cam-fixed state) ;; (state camera-slave)
|
|
;; (define-extern cam-fixed-read-entity state) ;; (state camera-slave)
|
|
;; (define-extern cam-pov state) ;; (state camera-slave)
|
|
;; (define-extern cam-pov180 state) ;; (state camera-slave)
|
|
;; (define-extern cam-pov-track state) ;; (state camera-slave)
|
|
;; (define-extern cam-standoff-calc-trans function) ;; (function vector :behavior camera-slave)
|
|
;; (define-extern cam-standoff state) ;; (state camera-slave)
|
|
;; (define-extern cam-standoff-read-entity state) ;; (state camera-slave)
|
|
;; (define-extern *CAM_EYE-bank* cam-eye-bank) ;; cam-eye-bank
|
|
;; (define-extern cam-eye state) ;; (state camera-slave)
|
|
;; (define-extern cam-curve-closest-point function)
|
|
;; (define-extern cam-tube-sled state)
|
|
;; (define-extern cam-spline state) ;; (state camera-slave)
|
|
;; (define-extern cam-decel state) ;; (state camera-slave)
|
|
;; (define-extern cam-endlessfall state) ;; (state camera-slave)
|
|
;; (define-extern cam-circular-position-into-max-angle function) ;; (function vector vector float vector :behavior camera-slave)
|
|
;; (define-extern cam-circular-position function) ;; (function symbol vector :behavior camera-slave)
|
|
;; (define-extern cam-circular-code function) ;; (function float :behavior camera-slave)
|
|
;; (define-extern cam-circular state) ;; (state camera-slave)
|
|
;; (define-extern cam-lookat state) ;; (state camera-slave)
|
|
;; (define-extern *CAM_STRING-bank* cam-string-bank) ;; cam-string-bank
|
|
;; (define-extern cam-string-find-position-rel! function) ;; (function vector symbol)
|
|
;; (define-extern cam-string-set-position-rel! function) ;; (function vector cam-slave-options :behavior camera-slave)
|
|
;; (define-extern string-push-help function) ;; (function float)
|
|
;; (define-extern cam-draw-collide-cache function) ;; (function collide-cache none)
|
|
;; (define-extern dist-info-init function) ;; (function collide-los-dist-info none)
|
|
;; (define-extern dist-info-valid? function) ;; (function collide-los-dist-info symbol)
|
|
;; (define-extern dist-info-append function) ;; (function collide-los-dist-info vector none)
|
|
;; (define-extern dist-info-print function) ;; (function collide-los-dist-info string object)
|
|
;; (define-extern los-cw-ccw function) ;; (function (inline-array collide-cache-tri) vector vector float collide-los-result vector float symbol :behavior camera-slave)
|
|
;; (define-extern cam-los-spline-collide function) ;; (function vector vector pat-surface float)
|
|
;; (define-extern cam-los-setup-lateral function) ;; (function collide-los-result vector vector symbol :behavior camera-slave)
|
|
;; (define-extern cam-los-collide function) ;; (function vector vector collide-los-result pat-surface symbol :behavior camera-slave)
|
|
;; (define-extern cam-string-follow function) ;; (function object :behavior camera-slave)
|
|
;; (define-extern cam-string-line-of-sight function) ;; (function vector :behavior camera-slave)
|
|
;; (define-extern cam-dist-analog-input function) ;; (function int float float)
|
|
;; (define-extern cam-string-joystick function) ;; (function float :behavior camera-slave)
|
|
;; (define-extern cam-string-find-hidden function) ;; (function none :behavior camera-slave)
|
|
;; (define-extern cam-string-move function) ;; (function object :behavior camera-slave)
|
|
;; (define-extern cam-string-code function) ;; (function vector :behavior camera-slave)
|
|
;; (define-extern set-string-params function) ;; (function vector :behavior camera-slave)
|
|
;; (define-extern cam-string state) ;; (state camera-slave)
|
|
;; (define-extern *CAM_STICK-bank* cam-stick-bank) ;; cam-stick-bank
|
|
;; (define-extern cam-stick-code function) ;; (function none :behavior camera-slave)
|
|
;; (define-extern cam-stick state) ;; (state camera-slave)
|
|
;; (define-extern *CAM_BIKE-bank* cam-bike-bank) ;; cam-bike-bank
|
|
;; (define-extern cam-calc-bike-follow! function) ;; (function cam-rotation-tracker vector symbol vector :behavior camera-slave)
|
|
;; (define-extern cam-bike-code function) ;; (function none :behavior camera-slave)
|
|
;; (define-extern cam-bike state) ;; (state camera-slave)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sparticle-launcher ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sp-queued-launch-particles (structure)
|
|
((sp-system sparticle-system :offset-assert 0) ;; guessed by decompiler
|
|
(sp-launcher sparticle-launcher :offset-assert 4) ;; guessed by decompiler
|
|
(pos vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sp-launch-queue (basic)
|
|
((in-use int32 :offset-assert 4)
|
|
(queue sp-queued-launch-particles 256 :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2010
|
|
:flag-assert #x900002010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype particle-adgif-cache (basic)
|
|
((used int32 :offset-assert 4)
|
|
(last uint16 :offset-assert 8)
|
|
(lastgif adgif-shader :offset-assert 12)
|
|
(tidhash uint16 80 :offset-assert 16) ;; guessed by decompiler
|
|
(spadgif adgif-shader 80 :offset-assert 176) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x19b0
|
|
:flag-assert #x9000019b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sp-launch-stack (structure)
|
|
((ra basic :offset-assert 0)
|
|
(dummy0 basic :offset-assert 4)
|
|
(dummy1 basic :offset-assert 8)
|
|
(b-spfic basic :offset-assert 12)
|
|
(r16 uint128 :offset-assert 16)
|
|
(r17 uint128 :offset-assert 32)
|
|
(r18 uint128 :offset-assert 48)
|
|
(pos uint128 :offset-assert 64)
|
|
(matrix matrix :inline :offset-assert 80)
|
|
(l-spfic basic :offset-assert 144)
|
|
(birth-info sparticle-birthinfo :inline :offset-assert 160)
|
|
(sprite sprite-vec-data-2d :inline :offset-assert 192)
|
|
(r19 uint128 :offset-assert 240)
|
|
(r20 uint128 :offset-assert 256)
|
|
(r21 uint128 :offset-assert 272)
|
|
(r22 uint128 :offset-assert 288)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x130
|
|
:flag-assert #x900000130
|
|
;; field ra uses ~A with a signed load. field dummy0 uses ~A with a signed load. field dummy1 uses ~A with a signed load. field b-spfic uses ~A with a signed load. field l-spfic uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
;; sparticle-launcher is already defined!
|
|
|
|
;; (define-extern *part-id-table* object) ;; (array sparticle-launcher)
|
|
;; (define-extern *part-group-id-table* object) ;; (array sparticle-launch-group)
|
|
;; (define-extern *sp-temp* object) ;; float
|
|
;; (define-extern lookup-part-group-by-name function) ;; (function string sparticle-launch-group)
|
|
;; (define-extern lookup-part-group-pointer-by-name function) ;; (function string (pointer object))
|
|
;; (define-extern part-group-pointer? function) ;; (function pointer symbol)
|
|
;; (define-extern unlink-part-group-by-heap function) ;; (function kheap int)
|
|
;; (define-extern sp-init-fields! function) ;; (function (pointer float) (inline-array sp-field-init-spec) sp-field-id sp-field-id symbol (inline-array sp-field-init-spec))
|
|
;; (define-extern *sp-launcher-lock* object) ;; symbol
|
|
;; (define-extern *sp-launch-queue* object) ;; sp-launch-queue
|
|
;; (define-extern *sp-launcher-enable* object) ;; symbol
|
|
;; (define-extern particle-setup-adgif function) ;; (function adgif-shader int none)
|
|
;; (define-extern *particle-adgif-cache* object) ;; particle-adgif-cache
|
|
;; (define-extern particle-adgif-cache-flush function) ;; (function none)
|
|
;; (define-extern particle-adgif function) ;; (function adgif-shader texture-id none)
|
|
;; (define-extern particle-adgif-callback function) ;; (function adgif-shader texture-id none)
|
|
;; (define-extern sp-queue-launch function) ;; (function sparticle-system sparticle-launcher matrix int)
|
|
;; (define-extern sp-adjust-launch function) ;; (function sparticle-launchinfo sparticle-cpuinfo (inline-array sp-field-init-spec) matrix symbol none)
|
|
;; (define-extern sp-euler-convert function) ;; (function sparticle-launchinfo sparticle-cpuinfo none)
|
|
;; (define-extern sp-rotate-system function) ;; (function sparticle-launchinfo sparticle-cpuinfo transformq none)
|
|
;; (define-extern sp-launch-particles-var function) ;; (function sparticle-system sparticle-launcher matrix sparticle-launch-state sparticle-launch-control float none)
|
|
;; (define-extern *death-adgif* object) ;; adgif-shader
|
|
;; (define-extern sp-launch-particles-death function) ;; (function sparticle-system sparticle-launcher vector none)
|
|
;; (define-extern sp-clear-queue function) ;; (function none)
|
|
;; (define-extern sp-relaunch-setup-fields function) ;; (function object sparticle-launcher sparticle-cpuinfo sprite-vec-data-3d none)
|
|
;; (define-extern sp-relaunch-particle-2d function) ;; (function object sparticle-launcher sparticle-cpuinfo sprite-vec-data-3d none)
|
|
;; (define-extern sp-relaunch-particle-3d function) ;; (function object sparticle-launcher sparticle-cpuinfo sprite-vec-data-3d none)
|
|
;; (define-extern execute-particle-local-space-engine function)
|
|
;; (define-extern local-space-camera function)
|
|
;; (define-extern local-space-proc-joint function)
|
|
;; (define-extern execute-part-engine function) ;; (function none)
|
|
;; (define-extern sparticle-track-root function) ;; (function object sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-track-root-prim function) ;; (function object sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-track-joint function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-turn-to-vel function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d none)
|
|
;; (define-extern sparticle-rotate-to-vel-3d function)
|
|
;; (define-extern birth-func-clean function)
|
|
;; (define-extern birth-func-process-clock function)
|
|
;; (define-extern birth-func-copy-rot-color function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern *global-toggle* object) ;; int
|
|
;; (define-extern birth-func-copy2-rot-color function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern birth-func-copy-omega-to-z function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern birth-func-random-next-time function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern sparticle-respawn-heights function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-respawn-timer function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-texture-animate function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-texture-day-night function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-2d none)
|
|
;; (define-extern sparticle-mode-animate function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-2d none)
|
|
;; (define-extern sparticle-motion-blur function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-motion-blur-old function) ;; (function object sparticle-cpuinfo sprite-vec-data-3d object)
|
|
;; (define-extern sparticle-set-conerot function) ;; (function sparticle-launcher vector none)
|
|
;; (define-extern sparticle-next-on-mode-1 function) ;; (function sparticle-system sparticle-cpuinfo sparticle-launchinfo float)
|
|
;; (define-extern check-ground-bounce function) ;; (function sparticle-system sparticle-cpuinfo sparticle-launchinfo float)
|
|
;; (define-extern check-drop-group-center function) ;; (function sparticle-system sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern check-bubble-height function)
|
|
;; (define-extern check-raise-group-center function)
|
|
;; (define-extern birth-func-y->userdata function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
;; (define-extern birth-func-ocean-height function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
;; (define-extern birth-func-camera-orient function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern birth-func-set-parent-pntr function)
|
|
;; (define-extern birth-func-get-parent-quat function)
|
|
;; (define-extern spt-func-camera-facing-orbiter function)
|
|
;; (define-extern *particle-quat* object) ;; quaternion
|
|
;; (define-extern birth-func-set-quat function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern *particle-vel* object) ;; vector
|
|
;; (define-extern birth-func-set-vel function) ;; (function object sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern birth-func-texture-group function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern rot-to-particle function)
|
|
;; (define-extern birth-func-flip-based-on-scale function)
|
|
;; (define-extern sparticle-2d-spline-align function)
|
|
;; (define-extern sparticle-2d-spline-align-instant function)
|
|
;; (define-extern birth-func-inherit-size function)
|
|
;; (define-extern birth-func-texture-group-2d function)
|
|
;; (define-extern birth-func-set-vel-2d function)
|
|
;; (define-extern sparticle-3d-rotate-xz-to-camera function)
|
|
;; (define-extern spt-func-relative-pos function)
|
|
;; (define-extern spt-func-turn-to-vel-radial function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; entity-table ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *entity-info* array) ;; (array entity-info)
|
|
;; (define-extern entity-info-lookup function) ;; (function type entity-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; roboguard-city ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype roboguard-city (kg-squad-member)
|
|
((los los-control :inline :offset-assert 1136)
|
|
(rotation-matrix matrix :inline :offset-assert 1312)
|
|
(me-to-focus-dir vector :inline :offset-assert 1376)
|
|
(me-to-focus-angle float :offset-assert 1392)
|
|
(robo-flags uint16 :offset-assert 1396)
|
|
(torso-aim-blend float :offset-assert 1400)
|
|
(torso-angle float :offset-assert 1404)
|
|
(torso-seek-speed float :offset-assert 1408)
|
|
(torso-to-focus-angle float :offset-assert 1412)
|
|
(last-torso-frame-num float :offset-assert 1416)
|
|
(stand-angle-threshold float :offset-assert 1420)
|
|
(attack-distance float :offset-assert 1424)
|
|
(attack-dist-scalar float :offset-assert 1428)
|
|
(fire-time uint64 :offset-assert 1432)
|
|
(last-attack-time uint64 :offset-assert 1440)
|
|
(fired-this-time? basic :offset-assert 1448)
|
|
(last-roll-time uint64 :offset-assert 1456)
|
|
(cannot-reach-target? basic :offset-assert 1464)
|
|
(cannot-reach-target-start-time uint64 :offset-assert 1472)
|
|
(frustrate-roll-time uint64 :offset-assert 1480)
|
|
(target-status squad-target-status :inline :offset-assert 1488)
|
|
(last-update-chase-pos-time uint64 :offset-assert 1560)
|
|
(random-offset-search float :offset-assert 1568)
|
|
(pursuit-start-time uint64 :offset-assert 1576)
|
|
(dizzy-start-time uint64 :offset-assert 1584)
|
|
(roll-sound uint32 :offset-assert 1592)
|
|
)
|
|
:method-count-assert 241
|
|
:size-assert #x63c
|
|
:flag-assert #xf105c0063c
|
|
(:methods
|
|
(roboguard-city-method-233 () none) ;; 233
|
|
(roboguard-city-method-234 () none) ;; 234
|
|
(roboguard-city-method-235 () none) ;; 235
|
|
(roboguard-city-method-236 () none) ;; 236
|
|
(roboguard-city-method-237 () none) ;; 237
|
|
(roboguard-city-method-238 () none) ;; 238
|
|
(roboguard-city-method-239 () none) ;; 239
|
|
(roboguard-city-method-240 () none) ;; 240
|
|
)
|
|
(:state-methods
|
|
dizzy ;; 230
|
|
hostile ;; 38
|
|
wait ;; 190
|
|
roll-enter ;; 226
|
|
active ;; 34
|
|
idle ;; 33
|
|
explode ;; 225
|
|
stare ;; 37
|
|
reposition ;; 229
|
|
roll-exit ;; 227
|
|
roll-chase ;; 228
|
|
giant-hostile ;; 232
|
|
die ;; 40
|
|
hostile-stand ;; 222
|
|
close-attack ;; 223
|
|
knocked ;; 31
|
|
shoot-attack ;; 224
|
|
knocked-recover ;; 32
|
|
exit-transport ;; 231
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype roboguard-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *roboguard-city-debris-params* debris-static-params)
|
|
;; (define-extern *roboguard-city-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern roboguard-city-turn-torso-post function)
|
|
;; (define-extern roboguard-city-turret-code function)
|
|
;; (define-extern roboguard-city-idle-code function)
|
|
;; (define-extern spawn-roboguard-projectile function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; loader ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype spooler-block (basic)
|
|
((anim spool-anim :offset-assert 4) ;; guessed by decompiler
|
|
(idle art-joint-anim :offset-assert 8) ;; guessed by decompiler
|
|
(exit art-joint-anim :offset-assert 12) ;; guessed by decompiler
|
|
(break-func (function process-drawable object) :offset-assert 16) ;; guessed by decompiler
|
|
(flags uint32 :offset-assert 20)
|
|
(part int32 :offset-assert 24)
|
|
(part-audio-start float :offset-assert 28)
|
|
(old-status uint16 :offset-assert 32)
|
|
(old-pos int32 :offset-assert 36)
|
|
(good-time uint64 :offset-assert 40) ;; time-frame
|
|
(old-time uint64 :offset-assert 48) ;; time-frame
|
|
(good-count int32 :offset-assert 56)
|
|
(sid sound-id :offset-assert 60) ;; guessed by decompiler
|
|
(real-start-time uint64 :offset-assert 64) ;; time-frame
|
|
(paused? symbol :offset-assert 72) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype load-dir (basic)
|
|
((level basic :offset-assert 4)
|
|
(allocated-length uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x10
|
|
:flag-assert #xb00000010
|
|
;; Failed to read some fields.
|
|
(:methods
|
|
;; (new (symbol type int level) _type_ 0)
|
|
(load-dir-method-9 () none) ;; 9 ;; (load-to-heap-by-name (_type_ string symbol kheap int) art-group 9)
|
|
(load-dir-method-10 () none) ;; 10 ;; (set-loaded-art (_type_ art-group) art-group 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gui-control (basic)
|
|
((engine engine :offset-assert 4) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xd30
|
|
:flag-assert #x1a00000d30
|
|
(:methods
|
|
;; (new (symbol type int) _type_ 0)
|
|
(gui-control-method-9 () none) ;; 9 ;; (add-process (_type_ process gui-channel gui-action string float time-frame) sound-id 9)
|
|
(gui-control-method-10 () none) ;; 10 ;; (remove-process (_type_ process gui-channel) none 10)
|
|
(gui-control-method-11 () none) ;; 11 ;; (stop-str (_type_ gui-connection) int 11)
|
|
(gui-control-method-12 () none) ;; 12 ;; (gui-control-method-12 (_type_ process gui-channel gui-action string int float sound-id) sound-id 12)
|
|
(gui-control-method-13 () none) ;; 13 ;; (update (_type_ symbol) int 13)
|
|
(gui-control-method-14 () none) ;; 14 ;; (lookup-gui-connection-id (_type_ string gui-channel gui-action) sound-id 14)
|
|
(gui-control-method-15 () none) ;; 15 ;; (lookup-gui-connection (_type_ process gui-channel string sound-id) gui-connection 15)
|
|
(gui-control-method-16 () none) ;; 16 ;; (set-action! (_type_ gui-action sound-id gui-channel gui-action string (function gui-connection symbol) process) int 16)
|
|
(gui-control-method-17 () none) ;; 17 ;; (get-status (_type_ sound-id) gui-status 17)
|
|
(gui-control-method-18 () none) ;; 18 ;; (gui-control-method-18 (_type_ gui-channel) symbol 18)
|
|
(gui-control-method-19 () none) ;; 19 ;; (handle-command-list (_type_ gui-channel gui-connection) symbol 19)
|
|
(gui-control-method-20 () none) ;; 20 ;; (set-falloff! (_type_ sound-id symbol int int int) gui-connection 20)
|
|
(gui-control-method-21 () none) ;; 21 ;; (gui-control-method-21 (_type_ gui-connection vector) int 21)
|
|
(gui-control-method-22 () none) ;; 22 ;; (gui-control-method-22 (_type_ gui-connection process symbol) none 22)
|
|
(gui-control-method-23 () none) ;; 23 ;; (handle-command (_type_ gui-channel gui-channel symbol gui-connection) symbol 23)
|
|
(gui-control-method-24 () none) ;; 24 ;; (channel-id-set! (_type_ gui-connection sound-id) int 24)
|
|
(gui-control-method-25 () none) ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern drawable-load function) ;; (function drawable kheap drawable)
|
|
;; (define-extern art-load function) ;; (function string kheap art)
|
|
;; (define-extern art-group-load-check function) ;; (function string kheap int art-group)
|
|
;; (define-extern external-art-buffer-init function) ;; (function external-art-buffer int)
|
|
;; (define-extern *preload-spool-anims* object) ;; symbol
|
|
;; (define-extern ja-play-spooled-anim function) ;; (function spool-anim art-joint-anim art-joint-anim (function process-drawable symbol) int :behavior process-drawable)
|
|
;; (define-extern ja-abort-spooled-anim function) ;; (function spool-anim art-joint-anim int int :behavior process-drawable)
|
|
;; (define-extern *gui-control* object) ;; gui-control
|
|
;; (define-extern *art-control* object) ;; external-art-control
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wascitya-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wascity-stad-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype waspala-elevator (elevator)
|
|
()
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; game-task ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-mesh-editor-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; vector-array is already defined!
|
|
|
|
#|
|
|
(deftype int16-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-poly (structure)
|
|
((poly-id uint32 :offset-assert 0)
|
|
(flags uint32 :offset-assert 4)
|
|
(index basic :offset-assert 8)
|
|
(insert-pos uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x10
|
|
:flag-assert #xf00000010
|
|
(:methods
|
|
(nav-mesh-poly-method-9 () none) ;; 9
|
|
(nav-mesh-poly-method-10 () none) ;; 10
|
|
(nav-mesh-poly-method-11 () none) ;; 11
|
|
(nav-mesh-poly-method-12 () none) ;; 12
|
|
(nav-mesh-poly-method-13 () none) ;; 13
|
|
(nav-mesh-poly-method-14 () none) ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-poly-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-tri-quad (structure)
|
|
((indices UNKNOWN 4 :offset-assert 0)
|
|
(poly uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-tri-quad-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-editable (structure)
|
|
((flags uint32 :offset-assert 0)
|
|
(verts basic :offset-assert 4)
|
|
(tris basic :offset-assert 8)
|
|
(quads basic :offset-assert 12)
|
|
(navmesh-id uint32 :offset-assert 16)
|
|
(idx uint32 :offset-assert 20)
|
|
(level-name basic :offset-assert 24)
|
|
(level-id uint32 :offset-assert 28)
|
|
(polys basic :offset-assert 32)
|
|
(selected-poly uint32 :offset-assert 36)
|
|
)
|
|
:method-count-assert 19
|
|
:size-assert #x28
|
|
:flag-assert #x1300000028
|
|
(:methods
|
|
(nav-mesh-editable-method-9 () none) ;; 9
|
|
(nav-mesh-editable-method-10 () none) ;; 10
|
|
(nav-mesh-editable-method-11 () none) ;; 11
|
|
(nav-mesh-editable-method-12 () none) ;; 12
|
|
(nav-mesh-editable-method-13 () none) ;; 13
|
|
(nav-mesh-editable-method-14 () none) ;; 14
|
|
(nav-mesh-editable-method-15 () none) ;; 15
|
|
(nav-mesh-editable-method-16 () none) ;; 16
|
|
(nav-mesh-editable-method-17 () none) ;; 17
|
|
(nav-mesh-editable-method-18 () none) ;; 18
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-editable-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-editor-undo (structure)
|
|
((current-nav-mesh nav-mesh-editable :offset-assert 0)
|
|
(selected-poly uint32 :offset-assert 4)
|
|
(index basic :offset-assert 8)
|
|
(insert-pos uint32 :offset-assert 12)
|
|
(verts basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x14
|
|
:flag-assert #xa00000014
|
|
(:methods
|
|
(nav-mesh-editor-undo-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-editor-undo-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-mesh-editor (process-drawable)
|
|
((close-menu-time uint64 :offset-assert 200)
|
|
(external-cam-mode basic :offset-assert 208)
|
|
(mouse-pressed uint64 :offset-assert 216)
|
|
(mouse-screen-pos vector :inline :offset-assert 224)
|
|
(mouse-pos vector :inline :offset-assert 240)
|
|
(mouse-end vector :inline :offset-assert 256)
|
|
(mouse-hit vector :inline :offset-assert 272)
|
|
(mouse-hit-pick vector :inline :offset-assert 288)
|
|
(mouse-snap vector :inline :offset-assert 304)
|
|
(mouse-normal vector :inline :offset-assert 320)
|
|
(mouse-collide basic :offset-assert 336)
|
|
(mouse-tumble-dist float :offset-assert 340)
|
|
(mouse-tumble vector :inline :offset-assert 352)
|
|
(manipulator-pos vector :inline :offset-assert 368)
|
|
(manipulator-back-pos vector :inline :offset-assert 384)
|
|
(lock-action basic :offset-assert 400)
|
|
(mouse-action uint32 :offset-assert 404)
|
|
(mouse-action-pos-ref vector :inline :offset-assert 416)
|
|
(nav-meshes basic :offset-assert 432)
|
|
(current-nav-mesh nav-mesh-editable :offset-assert 436)
|
|
(manipulator manipulator :inline :offset-assert 448)
|
|
(level-name basic :offset-assert 624)
|
|
(level-id uint32 :offset-assert 628)
|
|
(undo-min uint32 :offset-assert 632)
|
|
(undo-id uint32 :offset-assert 636)
|
|
(undo-max uint32 :offset-assert 640)
|
|
(undos basic :offset-assert 644)
|
|
(hide-unselected basic :offset-assert 648)
|
|
(allow-snap basic :offset-assert 652)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #x290
|
|
:flag-assert #x1c02100290
|
|
(:methods
|
|
(nav-mesh-editor-method-20 () none) ;; 20
|
|
(nav-mesh-editor-method-21 () none) ;; 21
|
|
(nav-mesh-editor-method-22 () none) ;; 22
|
|
(nav-mesh-editor-method-23 () none) ;; 23
|
|
(nav-mesh-editor-method-24 () none) ;; 24
|
|
(nav-mesh-editor-method-25 () none) ;; 25
|
|
(nav-mesh-editor-method-26 () none) ;; 26
|
|
(nav-mesh-editor-method-27 () none) ;; 27
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *nav-mesh-editor* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rubblea-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern rubblea-login function)
|
|
;; (define-extern rubblea-activate function)
|
|
;; (define-extern rubblea-deactivate function)
|
|
;; (define-extern lpattack-login function)
|
|
;; (define-extern lpattack-logout function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-reaction-target ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern poly-find-nearest-edge function) ;; (function nav-poly (inline-array vector) vector vector nav-poly)
|
|
;; (define-extern target-collision-low-coverage function) ;; (function control-info collide-query vector (pointer cshape-reaction-flags) (pointer collide-status) (pointer symbol) none)
|
|
;; (define-extern target-collision-reaction function) ;; (function control-info collide-query vector vector collide-status :behavior target)
|
|
;; (define-extern target-collision-no-reaction function) ;; (function control-info collide-query vector vector none)
|
|
;; (define-extern *collide-edge-board-spec* object) ;; collide-edge-spec
|
|
;; (define-extern rail-surface-touch function) ;; (function none :behavior target)
|
|
;; (define-extern gravel-surface-touch function) ;; (function none)
|
|
;; (define-extern mushroom-surface-touch function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-race ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern target-falling-trans function) ;; (function symbol time-frame none :behavior target)
|
|
;; (define-extern *slide-down-mods* surface) ;; surface
|
|
;; (define-extern *slide-jump-mods* surface) ;; surface
|
|
;; (define-extern init-var-jump function) ;; (function float float symbol symbol vector float vector :behavior target)
|
|
;; (define-extern mod-var-jump function) ;; (function symbol symbol symbol vector vector :behavior target)
|
|
;; (define-extern *duck-mods* surface) ;; surface
|
|
;; (define-extern target-jump-top-anim function) ;; (function none :behavior target)
|
|
;; (define-extern *attack-mods* surface) ;; surface
|
|
;; (define-extern *attack-end-mods* object) ;; surface
|
|
;; (define-extern *attack-find-mods* object)
|
|
;; (define-extern *run-attack-mods* surface) ;; surface
|
|
;; (define-extern *jump-attack-mods* surface) ;; surface
|
|
;; (define-extern *uppercut-mods* object) ;; surface
|
|
;; (define-extern *uppercut-jump-mods* surface) ;; surface
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kg-squad-member-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hatred-instance-info (structure)
|
|
((hated-target uint64 :offset-assert 0)
|
|
(hatred-value float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-squad-member (citizen)
|
|
((hatred-memory UNKNOWN 3 :offset-assert 1032)
|
|
(last-choose-new-enemy-time uint64 :offset-assert 1080)
|
|
(current-enemy uint64 :offset-assert 1088)
|
|
(kg-type uint8 :offset-assert 1096)
|
|
(choose-new-enemy-delay-time uint64 :offset-assert 1104)
|
|
(next-update-target-time uint64 :offset-assert 1112)
|
|
(minimap connection-minimap :offset-assert 1120)
|
|
)
|
|
:method-count-assert 222
|
|
:size-assert #x464
|
|
:flag-assert #xde03f00464
|
|
(:methods
|
|
(kg-squad-member-method-216 () none) ;; 216
|
|
(kg-squad-member-method-217 () none) ;; 217
|
|
(kg-squad-member-method-218 () none) ;; 218
|
|
(kg-squad-member-method-219 () none) ;; 219
|
|
(kg-squad-member-method-220 () none) ;; 220
|
|
(kg-squad-member-method-221 () none) ;; 221
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; settings ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern get-current-language function) ;; (function language-enum)
|
|
;; (define-extern *setting-control* object) ;; setting-control
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flut-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mood-tables ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *no-cloud-haze-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *no-cloud-clear-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *no-cloud-smog-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *overcast-fog-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *overcast-clear-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *overcast-rain-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *storm-fog-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *storm-clear-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *storm-rain-mood-fog-table* object) ;; mood-fog-table
|
|
;; (define-extern *desert-mood-fog-table* object)
|
|
;; (define-extern *sandstorm-start-mood-fog-table* object)
|
|
;; (define-extern *sandstorm-end-mood-fog-table* object)
|
|
;; (define-extern *no-cloud-mood-color-table* object) ;; mood-color-table
|
|
;; (define-extern *overcast-mood-color-table* object) ;; mood-color-table
|
|
;; (define-extern *storm-mood-color-table* object) ;; mood-color-table
|
|
;; (define-extern *desert-mood-color-table* object)
|
|
;; (define-extern *sandstorm-start-mood-color-table* object)
|
|
;; (define-extern *sandstorm-end-mood-color-table* object)
|
|
;; (define-extern *no-cloud-mood-channel-group* object) ;; mood-channel-group
|
|
;; (define-extern *overcast-mood-channel-group* object) ;; mood-channel-group
|
|
;; (define-extern *stormy-mood-channel-group* object) ;; mood-channel-group
|
|
;; (define-extern *clouds-000* object) ;; mood-clouds
|
|
;; (define-extern *clouds-125* object) ;; mood-clouds
|
|
;; (define-extern *clouds-250* object) ;; mood-clouds
|
|
;; (define-extern *clouds-375* object) ;; mood-clouds
|
|
;; (define-extern *clouds-500* object) ;; mood-clouds
|
|
;; (define-extern *clouds-625* object) ;; mood-clouds
|
|
;; (define-extern *clouds-750* object) ;; mood-clouds
|
|
;; (define-extern *clouds-875* object) ;; mood-clouds
|
|
;; (define-extern *clouds-1000* object) ;; mood-clouds
|
|
;; (define-extern *mood-direction-table* object) ;; mood-direction-table
|
|
;; (define-extern *mood-sky-table* object) ;; mood-sky-table
|
|
;; (define-extern *mood-interp-table* object) ;; sky-color-day
|
|
;; (define-extern init-mood-control function) ;; (function mood-control none)
|
|
;; (define-extern *mood-control* mood-control) ;; mood-control
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern bot-simple-check-too-far function) ;; (function bot int)
|
|
;; (define-extern bot-check-too-far-always-okay function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype lava-state (structure)
|
|
((lava float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern palette-select-special function) ;; (function mood-context-core3 symbol)
|
|
;; (define-extern clear-mood-times function) ;; (function mood-context symbol)
|
|
;; (define-extern update-mood-itimes function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-direction function) ;; (function mood-context-core3 mood-table float float)
|
|
;; (define-extern update-mood-exterior function) ;; (function mood-context-core3 mood-table float int object)
|
|
;; (define-extern copy-mood-exterior function) ;; (function mood-context symbol)
|
|
;; (define-extern copy-mood-exterior-ambi function) ;; (function mood-context symbol none)
|
|
;; (define-extern clear-mood-context function) ;; (function mood-context symbol)
|
|
;; (define-extern update-mood-interior function) ;; (function mood-context float)
|
|
;; (define-extern update-mood-interior-ambient function)
|
|
;; (define-extern update-mood-flames function) ;; (function mood-context int int int float float float float :behavior time-of-day-proc)
|
|
;; (define-extern *flash0* array) ;; (array float)
|
|
;; (define-extern *flash1* array) ;; (array float)
|
|
;; (define-extern *flash2* array) ;; (array float)
|
|
;; (define-extern *flash3* array) ;; (array float)
|
|
;; (define-extern *flash4* array) ;; (array float)
|
|
;; (define-extern *flash5* array) ;; (array float)
|
|
;; (define-extern *flash6* array) ;; (array float)
|
|
;; (define-extern *flash7* array) ;; (array float)
|
|
;; (define-extern update-mood-light function) ;; (function mood-context int int float float float float float float)
|
|
;; (define-extern update-mood-lava function) ;; (function mood-context int int float float float float float float)
|
|
;; (define-extern update-mood-flicker function) ;; (function mood-context int int none)
|
|
;; (define-extern update-mood-florescent function) ;; (function mood-context int int float)
|
|
;; (define-extern update-mood-electricity function) ;; (function mood-context int int float float none)
|
|
;; (define-extern update-mood-pulse function) ;; (function mood-context int int float float float float none)
|
|
;; (define-extern update-mood-strobe function) ;; (function mood-context int int int float float)
|
|
;; (define-extern update-mood-caustics function) ;; (function mood-context int float float float float float)
|
|
;; (define-extern overide-mood-fog function)
|
|
;; (define-extern overide-mood-color function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mood-funcs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ctywide-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctysluma-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
(spec-0 sp-field-init-spec :offset-assert 16)
|
|
(spec-1 sp-field-init-spec :offset-assert 20)
|
|
(flicker float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyslumb-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(spec-0 sp-field-init-spec :offset-assert 8)
|
|
(spec-1 sp-field-init-spec :offset-assert 12)
|
|
(flicker float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyslumc-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(spec-0 sp-field-init-spec :offset-assert 8)
|
|
(spec-1 sp-field-init-spec :offset-assert 12)
|
|
(flicker float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctygenb-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
(flicker flicker-state :inline :offset-assert 15)
|
|
(spec-0 sp-field-init-spec :offset-assert 20)
|
|
(spec-1 sp-field-init-spec :offset-assert 24)
|
|
(spec-2 sp-field-init-spec :offset-assert 28)
|
|
(spec-3 sp-field-init-spec :offset-assert 32)
|
|
(next-flicker float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcitya-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcityb-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyport-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(spec-0 sp-field-init-spec :offset-assert 8)
|
|
(neon-min-bright float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctymarka-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(blink float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mountain-states (structure)
|
|
((light0 light-state :inline :offset-assert 0)
|
|
(light1 light-state :inline :offset-assert 8)
|
|
(spec-0 sp-field-init-spec :offset-assert 16)
|
|
(spec-1 sp-field-init-spec :offset-assert 20)
|
|
(spec-2 sp-field-init-spec :offset-assert 24)
|
|
(spec-3 sp-field-init-spec :offset-assert 28)
|
|
(spec-4 sp-field-init-spec :offset-assert 32)
|
|
(spec-5 sp-field-init-spec :offset-assert 36)
|
|
(spec-6 sp-field-init-spec :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyinda-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyindb-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flicker float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype atoll-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(explosion float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-default function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern update-mood-copy-parent function)
|
|
;; (define-extern get-sphere-interp function) ;; (function sphere vector float float float)
|
|
;; (define-extern update-mood-ctywide function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern update-mood-copy-ctywide function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-ctysluma function) ;; (function mood-context float)
|
|
;; (define-extern update-mood-ctysluma function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-ctyslumb function) ;; (function mood-context uint)
|
|
;; (define-extern update-mood-ctyslumb function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-ctyslumc function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-ctyslumc function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-ctygenb function)
|
|
;; (define-extern update-mood-ctygenb function)
|
|
;; (define-extern *mhcity-mood-fog-table* object)
|
|
;; (define-extern overide-mhcity-fog function)
|
|
;; (define-extern init-mood-mhcitya function)
|
|
;; (define-extern update-mood-mhcitya function)
|
|
;; (define-extern init-mood-mhcityb function)
|
|
;; (define-extern update-mood-mhcityb function)
|
|
;; (define-extern calc-lmhcity-palettes function)
|
|
;; (define-extern update-mood-lmhcitya function)
|
|
;; (define-extern update-mood-lmhcityb function)
|
|
;; (define-extern *ctyport-level* object)
|
|
;; (define-extern update-mood-ctyport function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern reset-marquee-color! function)
|
|
;; (define-extern add-marquee-color! function)
|
|
;; (define-extern update-mood-ctymarka function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-mountain function) ;; (function mood-context uint)
|
|
;; (define-extern update-mood-mountain function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern update-mood-ctyinda function)
|
|
;; (define-extern update-mood-ctyindb function)
|
|
;; (define-extern init-mood-atoll function) ;; (function mood-context float)
|
|
;; (define-extern update-mood-atoll function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern set-atoll-explosion! function) ;; (function float float)
|
|
;; (define-extern update-mood-atollext function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-wasp ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mh-wasp-shot (metalhead-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x210
|
|
:flag-assert #x2901900210
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-wasp (hover-enemy)
|
|
((gun-jmod joint-mod-rotate-local :inline :offset-assert 976)
|
|
(entity-group basic :offset-assert 1008)
|
|
(smoke-part basic :offset-assert 1012)
|
|
(engine-part basic :offset-assert 1016)
|
|
(old-gravity float :offset-assert 1024)
|
|
(knocked-anim int32 :offset-assert 1028)
|
|
(knocked-recover-anim int32 :offset-assert 1032)
|
|
(last-fire-time uint64 :offset-assert 1040)
|
|
(bridge-index int32 :offset-assert 1048)
|
|
(gun-x-angle float :offset-assert 1052)
|
|
(gun-x-angle-final float :offset-assert 1056)
|
|
(path-u float :offset-assert 1060)
|
|
(path-du float :offset-assert 1064)
|
|
(path-du-final float :offset-assert 1068)
|
|
(path-dest float :offset-assert 1072)
|
|
(sound-id uint32 :offset-assert 1076)
|
|
(attack-wait-min float :offset-assert 1080)
|
|
(attack-wait-max float :offset-assert 1084)
|
|
(attack-miss-dist-min float :offset-assert 1088)
|
|
(attack-miss-dist-max float :offset-assert 1092)
|
|
(attack-miss-dist-curr float :offset-assert 1096)
|
|
)
|
|
:method-count-assert 181
|
|
:size-assert #x44c
|
|
:flag-assert #xb503d0044c
|
|
(:methods
|
|
(mh-wasp-method-180 () none) ;; 180
|
|
)
|
|
(:state-methods
|
|
ambush ;; 47
|
|
notice ;; 35
|
|
die-explode ;; 179
|
|
hostile ;; 38
|
|
attack ;; 177
|
|
knocked-recover ;; 32
|
|
die-now ;; 178
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *mh-wasp-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *fact-info-mh-wasp-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *mh-wasp-enemy-info* enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hfrag-vu1 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern hfrag-vu1-block object)
|
|
;; (define-extern hfrag-setup-constants function)
|
|
;; (define-extern hfrag-add-constants function)
|
|
;; (define-extern hfrag-vu1-end-buffer function)
|
|
;; (define-extern hfrag-vu1-init-buf function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mood-funcs2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vinroom-states (structure)
|
|
((main float :offset-assert 0)
|
|
(flicker1 float :offset-assert 4)
|
|
(flicker2 float :offset-assert 8)
|
|
(warp float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hideout-states (structure)
|
|
((flame0 flames-state :inline :offset-assert 0)
|
|
(flame1 flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hiphog-states (structure)
|
|
((door entity :offset-assert 0) ;; guessed by decompiler
|
|
(door-current-interp float :offset-assert 4)
|
|
(door-target-interp float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype onintent-states (structure)
|
|
((flame0 flames-state :inline :offset-assert 0)
|
|
(flame1 flames-state :inline :offset-assert 8)
|
|
(flame2 flames-state :inline :offset-assert 16)
|
|
(green-flame flames-state :inline :offset-assert 24)
|
|
(totem0 flames-state :inline :offset-assert 32)
|
|
(totem1 flames-state :inline :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2f
|
|
:flag-assert #x90000002f
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype oracle-states (structure)
|
|
((flame0 flames-state :inline :offset-assert 0)
|
|
(flame1 flames-state :inline :offset-assert 8)
|
|
(flame2 flames-state :inline :offset-assert 16)
|
|
(blue-flame flames-state :inline :offset-assert 24)
|
|
(door-entity entity :offset-assert 32) ;; guessed by decompiler
|
|
(door-current float :offset-assert 36)
|
|
(door-target float :offset-assert 40)
|
|
(purple-flag symbol :offset-assert 44) ;; guessed by decompiler
|
|
(purple float :offset-assert 48)
|
|
(purple-noise float :offset-assert 52)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gungame-states (structure)
|
|
((florescent florescent-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype freehq-states (structure)
|
|
((flicker float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype default-interior-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype garage-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-default-interior function) ;; (function mood-context none :behavior time-of-day-proc)
|
|
;; (define-extern update-mood-default-interior-ambient function)
|
|
;; (define-extern update-vinroom-lights function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-vinroom function) ;; (function mood-context none :behavior time-of-day-proc)
|
|
;; (define-extern update-hideout-lights function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-hideout function) ;; (function mood-context none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-hiphog function) ;; (function mood-context none)
|
|
;; (define-extern update-hiphog-lights function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-hiphog function) ;; (function mood-context float none :behavior time-of-day-proc)
|
|
;; (define-extern update-onintent-lights function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-onintent function) ;; (function mood-context none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-oracle function) ;; (function mood-context symbol)
|
|
;; (define-extern update-mood-oracle function) ;; (function mood-context none :behavior time-of-day-proc)
|
|
;; (define-extern set-oracle-purple-flag! function) ;; (function symbol symbol)
|
|
;; (define-extern update-gungame-lights function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-gungame function) ;; (function mood-context none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-garage function) ;; (function mood-context symbol)
|
|
;; (define-extern update-garage-lights function) ;; (function mood-context none)
|
|
;; (define-extern update-mood-garage function) ;; (function mood-context object int none :behavior time-of-day-proc)
|
|
;; (define-extern update-mood-freehq function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lightning-new ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *lightning-alpha-additive* object)
|
|
;; (define-extern *lightning-alpha-blend* object)
|
|
;; (define-extern *lightning-alpha-subtractive* object)
|
|
;; (define-extern matrix<-vector-yz2! function)
|
|
;; (define-extern choose-nice-perp function)
|
|
;; (define-extern lightning-new-tracker-init-by-other function)
|
|
;; (define-extern create-lightning-tracker-new function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sky-tng ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern set-tex-offset function) ;; (function int int none)
|
|
;; (define-extern draw-large-polygon function)
|
|
;; (define-extern clip-polygon-against-positive-hyperplane function)
|
|
;; (define-extern clip-polygon-against-negative-hyperplane function)
|
|
;; (define-extern render-sky-quad function) ;; (function (inline-array sky-vertex) dma-buffer none)
|
|
;; (define-extern render-sky-tri function) ;; (function (inline-array sky-vertex) dma-buffer none)
|
|
;; (define-extern close-sky-buffer function) ;; (function dma-buffer none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fac-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-ffexplo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-ffexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fac-fighter-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-ffexplo-color* curve-color-fast)
|
|
;; (define-extern *range-ffexplo-alpha* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fac-fighter-explosion-texture-curve-settings* object)
|
|
;; (define-extern *range-fgtexplo-color* curve-color-fast)
|
|
;; (define-extern *range-fgtexplo-alpha* curve2d-fast)
|
|
;; (define-extern *range-fgtexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-fgtexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-fgtexplo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-fgtexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-fgtexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fac-tower-explosion-texture-curve-settings* object)
|
|
;; (define-extern *range-ftexplo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-ftexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fac-tank-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-ftexplo-color* curve-color-fast)
|
|
;; (define-extern *range-ftexplo-alpha* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fac-tank-explosion-texture-curve-settings* object)
|
|
;; (define-extern *range-gthoexplo-color* curve-color-fast)
|
|
;; (define-extern *range-gthoexplo-alpha* curve2d-fast)
|
|
;; (define-extern *range-gthoexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-gthoexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-gthoexplo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-gthoexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-gthoexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-gun-tower-hit-object-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; load-state ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern level-base-level-name function)
|
|
;; (define-extern *borrow-city-expansion-list* object)
|
|
;; (define-extern *borrow-city-status-list* object)
|
|
;; (define-extern borrow-city-expansion function)
|
|
;; (define-extern add-want-level function)
|
|
;; (define-extern *display-load-commands* object) ;; symbol
|
|
;; (define-extern *backup-load-state* object) ;; load-state
|
|
;; (define-extern *load-state* object) ;; load-state
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; level ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern level-memory-mode->string function)
|
|
;; (define-extern lookup-level-info function) ;; (function symbol level-load-info)
|
|
;; (define-extern remap-level-name function) ;; (function level-load-info symbol)
|
|
;; (define-extern add-bsp-drawable function) ;; (function bsp-header level symbol display-frame none)
|
|
;; (define-extern *login-state* object) ;; login-state
|
|
;; (define-extern *print-login* object) ;; symbol
|
|
;; (define-extern load-buffer-resize function) ;; (function level dgo-header none)
|
|
;; (define-extern level-find-borrow-slot function)
|
|
;; (define-extern level-update-after-load function) ;; (function level login-state level)
|
|
;; (define-extern bg function) ;; (function symbol none)
|
|
;; (define-extern play function) ;; (function symbol symbol int)
|
|
;; (define-extern play-boot function) ;; (function none)
|
|
;; (define-extern sound-bank-name->mode function)
|
|
;; (define-extern update-sound-banks function) ;; (function int)
|
|
;; (define-extern show-level function) ;; (function symbol int)
|
|
;; (define-extern *default-level* object) ;; level
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; water-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype water-control (basic)
|
|
((flags water-flag :offset-assert 4) ;; water-flags
|
|
(process target :offset-assert 8) ;; guessed by decompiler
|
|
(joint-index int32 :offset-assert 12)
|
|
(top-y-offset float :offset-assert 16)
|
|
(attack-id uint32 :offset-assert 20)
|
|
(enter-water-time uint64 :offset-assert 24) ;; time-frame
|
|
(wade-time uint64 :offset-assert 32) ;; time-frame
|
|
(on-water-time uint64 :offset-assert 40) ;; time-frame
|
|
(enter-swim-time uint64 :offset-assert 48) ;; time-frame
|
|
(swim-time uint64 :offset-assert 56) ;; time-frame
|
|
(base-height meters :offset-assert 64)
|
|
(wade-height meters :offset-assert 68)
|
|
(swim-height meters :offset-assert 72)
|
|
(surface-height meters :offset-assert 76)
|
|
(bottom-height meters :offset-assert 80)
|
|
(collide-height meters :offset-assert 84)
|
|
(height meters :offset-assert 88)
|
|
(height-offset float 4 :offset-assert 92) ;; guessed by decompiler
|
|
(base-ocean-offset meters :offset-assert 92)
|
|
(real-ocean-offset meters :offset-assert 92)
|
|
(ocean-offset meters :offset-assert 96)
|
|
(bob-offset meters :offset-assert 100)
|
|
(align-offset meters :offset-assert 104)
|
|
(swim-depth meters :offset-assert 108)
|
|
(bob smush-control :inline :offset-assert 112)
|
|
(ripple uint64 :offset-assert 144) ;; handle
|
|
(ripple-size meters :offset-assert 152)
|
|
(wake-size meters :offset-assert 156)
|
|
(bottom vector 2 :offset-assert 160) ;; guessed by decompiler
|
|
(top vector 2 :offset-assert 192) ;; guessed by decompiler
|
|
(enter-water-pos vector :inline :offset-assert 224)
|
|
(drip-old-pos vector :inline :offset-assert 240)
|
|
(drip-joint-index int32 :offset-assert 256)
|
|
(drip-wetness float :offset-assert 260)
|
|
(drip-time uint64 :offset-assert 264) ;; time-frame
|
|
(drip-speed float :offset-assert 272)
|
|
(drip-height meters :offset-assert 276)
|
|
(drip-mult float :offset-assert 280)
|
|
(distort-time uint64 :offset-assert 288) ;; time-frame
|
|
(enter-water-sound uint128 :offset-assert 304)
|
|
(normal vector :inline :offset-assert 320)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x150
|
|
:flag-assert #x1200000150
|
|
(:methods
|
|
;; (new (symbol type process int float float float) _type_ 0)
|
|
(water-control-method-9 () none) ;; 9 ;; (water-control-method-9 (_type_) none 9)
|
|
(water-control-method-10 () none) ;; 10 ;; (water-control-method-10 (_type_) none 10)
|
|
(water-control-method-11 () none) ;; 11 ;; (start-bobbing! (_type_ float int int) none 11)
|
|
(water-control-method-12 () none) ;; 12 ;; (distance-from-surface (_type_) float 12)
|
|
(water-control-method-13 () none) ;; 13 ;; (spawn-ripples (_type_ float vector int vector symbol) none 13)
|
|
(water-control-method-14 () none) ;; 14 ;; (display-water-marks? (_type_) symbol 14)
|
|
(water-control-method-15 () none) ;; 15 ;; (enter-water (_type_) none 15)
|
|
(water-control-method-16 () none) ;; 16 ;; (water-control-method-16 (_type_) none 16)
|
|
(water-control-method-17 () none) ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-vol (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; text ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; game-text-info is already defined!
|
|
|
|
;; (define-extern *expand-buf-number* object) ;; int
|
|
;; (define-extern *game-text-word* object) ;; string
|
|
;; (define-extern *game-text-line* object) ;; string
|
|
;; (define-extern *expanded-text-line0* object) ;; string
|
|
;; (define-extern *expanded-text-line1* object) ;; string
|
|
;; (define-extern *level-text-file-load-flag* object) ;; symbol
|
|
;; (define-extern convert-korean-text function) ;; (function string string)
|
|
;; (define-extern text-is-loading object) ;; symbol
|
|
;; (define-extern load-game-text-info function) ;; (function string (pointer object) kheap int)
|
|
;; (define-extern load-level-text-files function) ;; (function int none)
|
|
;; (define-extern draw-debug-text-box function) ;; (function font-context none)
|
|
;; (define-extern print-game-text-scaled function) ;; (function string float font-context bucket-id none)
|
|
;; (define-extern print-game-text function) ;; (function string font-context symbol int bucket-id float)
|
|
;; (define-extern disable-level-text-file-loading function) ;; (function none)
|
|
;; (define-extern enable-level-text-file-loading function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-probe ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collide-probe-stack-elem (structure)
|
|
((child uint32 :offset-assert 0)
|
|
(count uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collide-probe-stack (structure)
|
|
((data collide-probe-stack-elem 1024 :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4000
|
|
:flag-assert #x900004000
|
|
)
|
|
|#
|
|
|
|
;; (define-extern creates-new-method? function) ;; (function type int symbol)
|
|
;; (define-extern overrides-parent-method? function) ;; (function type int symbol)
|
|
;; (define-extern describe-methods function) ;; (function type symbol)
|
|
;; (define-extern indent-to function) ;; (function int none)
|
|
;; (define-extern probe-traverse-draw-node function) ;; (function draw-node int none)
|
|
;; (define-extern probe-traverse-inline-array-node function) ;; (function drawable-inline-array-node int none)
|
|
;; (define-extern probe-traverse-collide-fragment function) ;; (function drawable-tree-collide-fragment int none)
|
|
;; (define-extern *collide-probe-stack* object) ;; collide-probe-stack
|
|
;; (define-extern collide-vu0-block object) ;; vu-function
|
|
;; (define-extern collide-probe-node function) ;; (function (inline-array draw-node) int collide-list int)
|
|
;; (define-extern print-out function) ;; (function int object)
|
|
;; (define-extern collide-probe-instance-tie-collide-frags function) ;; (function none)
|
|
;; (define-extern collide-probe-instance-tie function) ;; (function object int collide-list int int)
|
|
;; (define-extern collide-probe-collide-fragment-tree-make-list function) ;; (function drawable-tree-collide-fragment collide-list none)
|
|
;; (define-extern collide-probe-instance-tie-tree-make-list function) ;; (function drawable-tree-instance-tie collide-list int)
|
|
;; (define-extern collide-upload-vu0 function) ;; (function none)
|
|
;; (define-extern collide-probe-make-list function) ;; (function level collide-list none)
|
|
;; (define-extern distc function) ;; (function vector vector float)
|
|
;; (define-extern interpolate function) ;; (function float float float float float float)
|
|
;; (define-extern misty-ambush-height function) ;; (function vector float)
|
|
;; (define-extern misty-ambush-height-probe function) ;; (function vector float float)
|
|
;; (define-extern pke-collide-test function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; entity ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype debug-actor-info (basic)
|
|
((name basic :offset-assert 4)
|
|
(handle uint64 :offset-assert 8) ;; handle
|
|
(process basic :offset-assert 16)
|
|
(pid int32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; actor-group is already defined!
|
|
|
|
#|
|
|
(deftype entity (res-lump)
|
|
((trans vector :inline :offset-assert 28)
|
|
(aid uint32 :offset-assert 44)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #x34
|
|
:flag-assert #x1b00000034
|
|
(:methods
|
|
(entity-method-22 () none) ;; 22 ;; (birth! (_type_) _type_ 22)
|
|
(entity-method-23 () none) ;; 23 ;; (kill! (_type_) _type_ 23)
|
|
(entity-method-24 () none) ;; 24 ;; (add-to-level! (_type_ level-group level actor-id) none 24)
|
|
(entity-method-25 () none) ;; 25 ;; (remove-from-level! (_type_ level-group) _type_ 25)
|
|
(entity-method-26 () none) ;; 26 ;; (get-level (_type_) level 26)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype entity-nav-mesh (entity)
|
|
((UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #x38
|
|
:flag-assert #x1d00000038
|
|
(:methods
|
|
(entity-nav-mesh-method-27 () none) ;; 27 ;; (initialize-nav-mesh! (_type_) none 27)
|
|
(entity-nav-mesh-method-28 () none) ;; 28 ;; (debug-draw (_type_) none 28)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype entity-actor (entity)
|
|
((etype type :offset-assert 52) ;; guessed by decompiler
|
|
(task uint8 :offset-assert 56) ;; game-task
|
|
(kill-mask task-mask :offset-assert 48) ;; guessed by decompiler
|
|
(vis-id int16 :offset-assert 58)
|
|
(quat vector :inline :offset-assert 60) ;; quaternion :inline
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x50
|
|
:flag-assert #x2100000050
|
|
(:methods
|
|
(entity-actor-method-27 () none) ;; 27 ;; (next-actor (_type_) entity-actor 27)
|
|
(entity-actor-method-28 () none) ;; 28 ;; (prev-actor (_type_) entity-actor 28)
|
|
(entity-actor-method-29 () none) ;; 29 ;; (debug-print (_type_ symbol type) none 29)
|
|
(entity-actor-method-30 () none) ;; 30 ;; (toggle-status (_type_ entity-perm-status symbol) none 30)
|
|
(entity-actor-method-31 () none) ;; 31 ;; (get-simple-travel-vector (_type_ vector vector vector object float) nav-mesh 31)
|
|
(entity-actor-method-32 () none) ;; 32 ;; (project-point-to-nav-mesh (_type_ vector vector nav-poly float) nav-poly 32)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *spawn-actors* object) ;; symbol
|
|
;; (define-extern *compact-actors* object) ;; symbol
|
|
;; (define-extern *vis-actors* object) ;; symbol
|
|
;; (define-extern entity-by-name function) ;; (function string entity)
|
|
;; (define-extern entity-by-type function) ;; (function type entity-actor)
|
|
;; (define-extern entity-by-aid function) ;; (function uint entity)
|
|
;; (define-extern entity-actor-from-level-name function) ;; (function symbol entity-actor)
|
|
;; (define-extern entity-nav-mesh-by-aid function) ;; (function actor-id entity-nav-mesh)
|
|
;; (define-extern nav-mesh-from-res-tag function) ;; (function entity symbol int nav-mesh)
|
|
;; (define-extern entity-by-meters function) ;; (function float float float entity-actor)
|
|
;; (define-extern process-by-ename function) ;; (function string process)
|
|
;; (define-extern entity-process-count function) ;; (function symbol int)
|
|
;; (define-extern entity-count function) ;; (function int)
|
|
;; (define-extern entity-remap-names function) ;; (function pair none)
|
|
;; (define-extern process-status-bits function) ;; (function process symbol none)
|
|
;; (define-extern process-entity-set! function) ;; (function process entity entity)
|
|
;; (define-extern process-task-mask function) ;; (function process task-mask)
|
|
;; (define-extern update-actor-vis-box function) ;; (function process-drawable vector vector none)
|
|
;; (define-extern expand-bounding-box function) ;; (function vector vector vector vector none)
|
|
;; (define-extern expand-bounding-box-from-nav-meshes function)
|
|
;; (define-extern expand-vis-box-with-point function) ;; (function entity vector none)
|
|
;; (define-extern *debug-actor-info* debug-actor-info) ;; debug-actor-info
|
|
;; (define-extern *pid-string* object) ;; string
|
|
;; (define-extern debug-actor function) ;; (function string none)
|
|
;; (define-extern debug-actor-process function)
|
|
;; (define-extern draw-actor-marks function) ;; (function process none)
|
|
;; (define-extern init-entity function) ;; (function process entity-actor type none)
|
|
;; (define-extern entity-deactivate-handler function) ;; (function process entity-actor none)
|
|
;; (define-extern check-for-rougue-process function) ;; (function process int int level none)
|
|
;; (define-extern process-drawable-scale-from-entity! function) ;; (function process-drawable entity none)
|
|
;; (define-extern process-drawable-from-entity! function) ;; (function process-drawable entity-actor none)
|
|
;; (define-extern reset-actors function) ;; (function symbol none)
|
|
;; (define-extern reset-cameras function) ;; (function none)
|
|
;; (define-extern entity-birth-no-kill function) ;; (function entity process)
|
|
;; (define-extern entity-task-complete-on function) ;; (function entity none)
|
|
;; (define-extern entity-task-complete-off function) ;; (function entity none)
|
|
;; (define-extern process-entity-status! function) ;; (function process entity-perm-status symbol entity-perm-status)
|
|
;; (define-extern find-nearest-entity function) ;; (function vector type entity)
|
|
;; (define-extern entity-speed-test function) ;; (function string entity)
|
|
;; (define-extern dump-entity-remap function) ;; (function object object none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-wheel ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vehicle-wheel-init-params (structure)
|
|
((skel basic :offset-assert 0)
|
|
(skel-blur basic :offset-assert 4)
|
|
(level basic :offset-assert 8)
|
|
(radius float :offset-assert 12)
|
|
(collision-mesh-index int8 :offset-assert 16)
|
|
(position vector :inline :offset-assert 32)
|
|
(rotation quaternion :inline :offset-assert 48)
|
|
(scale vector :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-wheel (rigid-body-object)
|
|
((collision-enable? basic :offset-assert 288)
|
|
(normal-look lod-set :inline :offset-assert 292)
|
|
(blur-look lod-set :inline :offset-assert 344)
|
|
)
|
|
:method-count-assert 59
|
|
:size-assert #x189
|
|
:flag-assert #x3b01100189
|
|
(:state-methods
|
|
idle ;; 28
|
|
explode ;; 56
|
|
fade-out ;; 57
|
|
die ;; 58
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *vehicle-wheel-constants* object)
|
|
;; (define-extern vehicle-wheel-init-by-other function)
|
|
;; (define-extern vehicle-wheel-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; effect-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *footstep-surface* object) ;; pat-surface
|
|
;; (define-extern *debug-effect-control* object) ;; symbol
|
|
;; (define-extern sound-name-with-material function) ;; (function string pat-surface string sound-name)
|
|
;; (define-extern effect-param->sound-spec function) ;; (function sound-spec (pointer float) int process-focusable sound-spec)
|
|
;; (define-extern target-land-effect function) ;; (function none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lfaccity-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype lfaccity-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(roty float :offset-assert 8)
|
|
(rotz float :offset-assert 12)
|
|
(rot-bob float :offset-assert 16)
|
|
(wobble float :offset-assert 20)
|
|
(bob float :offset-assert 24)
|
|
(zero-test int32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype faccity-pparticle-info (structure)
|
|
((original-pos vector :inline :offset-assert 0)
|
|
(inited? basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype faccity-pparticle-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lfaccity-pparticle-mover (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
(particles basic :offset-assert 204)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd4
|
|
:flag-assert #x16006000d4
|
|
(:methods
|
|
(lfaccity-pparticle-mover-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *faccity-part-updater* object)
|
|
;; (define-extern update-mood-lfaccity function)
|
|
;; (define-extern lfaccity-pparticle-mover-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; squad-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype squad-unit-settings (structure)
|
|
((target-count int8 :offset-assert 0)
|
|
(shot-count int8 :offset-assert 1)
|
|
(rand-shot-count int8 :offset-assert 2)
|
|
(inaccuracy float :offset-assert 4)
|
|
(acquire-delay uint16 :offset-assert 8)
|
|
(shot-delay uint16 :offset-assert 10)
|
|
(burst-delay uint16 :offset-assert 12)
|
|
(rand-burst-delay uint16 :offset-assert 14)
|
|
(rand-shot-delay uint16 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x12
|
|
:flag-assert #x900000012
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype squad-target-status (structure)
|
|
((flags squad-target-flag :offset-assert 0)
|
|
(handle uint64 :offset-assert 8)
|
|
(last-seen-time uint64 :offset-assert 16)
|
|
(position vector :inline :offset-assert 32)
|
|
(velocity vector :inline :offset-assert 48)
|
|
(threat-level float :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
;; field squad-target-flag is likely a value type.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype squad-alert-state (structure)
|
|
((flags squad-alert-flag :offset-assert 0)
|
|
(level uint8 :offset-assert 1)
|
|
(max-level uint8 :offset-assert 2)
|
|
(guards-in-sight-of-target int8 :offset-assert 3)
|
|
(guard-aim-count int8 :offset-assert 4)
|
|
(guard-inaccuracy-factor float :offset-assert 8)
|
|
(guard-target-level float :offset-assert 12)
|
|
(duration uint32 :offset-assert 16)
|
|
(start-time uint64 :offset-assert 24)
|
|
(notify-time uint64 :offset-assert 32)
|
|
(alarm-sound-id uint32 :offset-assert 40)
|
|
(target-status-array UNKNOWN 3 :offset-assert 48)
|
|
(target-status squad-target-status :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x120
|
|
:flag-assert #xa00000120
|
|
;; field squad-alert-flag is likely a value type.
|
|
(:methods
|
|
(squad-alert-state-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype primary-target-pos-vel (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(velocity vector :inline :offset-assert 16)
|
|
(time uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype squad-control (basic)
|
|
((sync-clock uint8 :offset-assert 4)
|
|
(sync-mask-8 uint8 :offset-assert 5)
|
|
(sync-mask-16 uint16 :offset-assert 6)
|
|
(sync-mask-32 uint32 :offset-assert 8)
|
|
(alert-state squad-alert-state :inline :offset-assert 16)
|
|
(primary-target-history UNKNOWN 16 :offset-assert 304)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x330
|
|
:flag-assert #x2200000330
|
|
(:methods
|
|
(squad-control-method-9 () none) ;; 9
|
|
(squad-control-method-10 () none) ;; 10
|
|
(squad-control-method-11 () none) ;; 11
|
|
(squad-control-method-12 () none) ;; 12
|
|
(squad-control-method-13 () none) ;; 13
|
|
(squad-control-method-14 () none) ;; 14
|
|
(squad-control-method-15 () none) ;; 15
|
|
(squad-control-method-16 () none) ;; 16
|
|
(squad-control-method-17 () none) ;; 17
|
|
(squad-control-method-18 () none) ;; 18
|
|
(squad-control-method-19 () none) ;; 19
|
|
(squad-control-method-20 () none) ;; 20
|
|
(squad-control-method-21 () none) ;; 21
|
|
(squad-control-method-22 () none) ;; 22
|
|
(squad-control-method-23 () none) ;; 23
|
|
(squad-control-method-24 () none) ;; 24
|
|
(squad-control-method-25 () none) ;; 25
|
|
(squad-control-method-26 () none) ;; 26
|
|
(squad-control-method-27 () none) ;; 27
|
|
(squad-control-method-28 () none) ;; 28
|
|
(squad-control-method-29 () none) ;; 29
|
|
(squad-control-method-30 () none) ;; 30
|
|
(squad-control-method-31 () none) ;; 31
|
|
(squad-control-method-32 () none) ;; 32
|
|
(squad-control-method-33 () none) ;; 33
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *waswide-squad-control* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctywide-obs-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype city-race-ring-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(angle float :offset-assert 12)
|
|
(boost float :offset-assert 16)
|
|
(dist float :offset-assert 20)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x18
|
|
:flag-assert #xa00000018
|
|
(:methods
|
|
(city-race-ring-info-method-9 () none) ;; 9 ;; (city-race-ring-info-method-9 (_type_ symbol) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-ambush-spot (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(obj-type uint8 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x11
|
|
:flag-assert #x900000011
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-ambush-info (structure)
|
|
((count int16 :offset-assert 0)
|
|
(array (inline-array city-ambush-spot) :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x8
|
|
:flag-assert #xa00000008
|
|
(:methods
|
|
(city-ambush-info-method-9 () none) ;; 9 ;; (city-ambush-info-method-9 (_type_ traffic-object-spawn-params) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-frag ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-touch ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype add-prims-touching-work (structure)
|
|
((tri1 collide-tri-result :offset-assert 0)
|
|
(tri2 collide-tri-result :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern get-intersect-point function) ;; (function vector touching-prims-entry collide-shape touching-shapes-entry vector)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; speech ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern speech-type->string function)
|
|
;; (define-extern gui-status->string function)
|
|
;; (define-extern *speech-control* object) ;; speech-control
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-edge-grab ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pbhp-stack-vars (structure)
|
|
((edge collide-edge-edge :offset-assert 0)
|
|
(allocated basic :offset-assert 4)
|
|
(neg-hold-pt vector :inline :offset-assert 16)
|
|
(split-vec vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype faei-stack-vars (structure)
|
|
((hold-edge-vec-norm vector :inline :offset-assert 0)
|
|
(adj-edge-vec-norm vector :inline :offset-assert 16)
|
|
(found-left? symbol :offset-assert 32) ;; guessed by decompiler
|
|
(left-dot float :offset-assert 36)
|
|
(found-right? symbol :offset-assert 40) ;; guessed by decompiler
|
|
(right-dot float :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *no-walk-surface* surface) ;; surface
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-formation-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype form-search-info (structure)
|
|
((form uint32 :offset-assert 0) ;; guessed by decompiler
|
|
(count int32 :offset-assert 4)
|
|
(pos-table (inline-array vector) :offset-assert 8) ;; guessed by decompiler
|
|
(actor-position vector 16 :offset-assert 16) ;; guessed by decompiler
|
|
(actor-valid? symbol 16 :offset-assert 272) ;; guessed by decompiler
|
|
(index-table uint32 16 :offset-assert 336) ;; guessed by decompiler
|
|
(dest-pos-table vector 16 :offset-assert 400) ;; guessed by decompiler
|
|
(best-mapping uint32 16 :offset-assert 656) ;; guessed by decompiler
|
|
(best-cost float :offset-assert 720)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2d4
|
|
:flag-assert #x9000002d4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-actor (structure)
|
|
((handle uint64 :offset-assert 0) ;; handle
|
|
(offset vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-formation-control (basic)
|
|
((search-info form-search-info :inline :offset-assert 16)
|
|
(entity entity :offset-assert 740) ;; guessed by decompiler
|
|
(anchor-proc uint64 :offset-assert 744) ;; handle
|
|
(actor-table handle 16 :offset-assert 752) ;; guessed by decompiler
|
|
(flags uint16 :offset-assert 880)
|
|
(formation-type uint64 :offset-assert 888) ;; formation-type
|
|
(center vector :inline :offset-assert 896)
|
|
(zone-to-world matrix :inline :offset-assert 912)
|
|
(world-to-zone matrix :inline :offset-assert 976)
|
|
(offset vector 2 :offset-assert 1040) ;; guessed by decompiler
|
|
(focus-quat quaternion :inline :offset-assert 1072)
|
|
(notice-dist float :offset-assert 1088) ;; meters
|
|
(rotation-inc float :offset-assert 1092)
|
|
(sub-graph-mask int32 :offset-assert 1096)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x44c
|
|
:flag-assert #x150000044c
|
|
(:methods
|
|
;; (new (symbol type object entity float vector float handle) _type_ 0)
|
|
(hover-formation-control-method-9 () none) ;; 9 ;; (set-anchor-proc (_type_ handle) int 9)
|
|
(hover-formation-control-method-10 () none) ;; 10 ;; (hover-formation-control-method-10 (_type_ vector vector float) symbol 10)
|
|
(hover-formation-control-method-11 () none) ;; 11 ;; (hover-formation-control-method-11 (_type_) int 11)
|
|
(hover-formation-control-method-12 () none) ;; 12 ;; (is-formation-type-in-range (_type_) symbol 12)
|
|
(hover-formation-control-method-13 () none) ;; 13 ;; (hover-formation-control-method-13 (_type_ vector) vector 13)
|
|
(hover-formation-control-method-14 () none) ;; 14 ;; (hover-formation-control-method-14 (_type_) none 14)
|
|
(hover-formation-control-method-15 () none) ;; 15 ;; (hover-formation-control-method-15 (_type_ vector vector) vector 15)
|
|
(hover-formation-control-method-16 () none) ;; 16 ;; (hover-formation-control-method-16 (_type_) object 16)
|
|
(hover-formation-control-method-17 () none) ;; 17 ;; (hover-formation-control-method-17 (_type_ process) int 17)
|
|
(hover-formation-control-method-18 () none) ;; 18 ;; (hover-formation-control-method-18 (_type_ process) int 18)
|
|
(hover-formation-control-method-19 () none) ;; 19 ;; (try-update-formation-type (_type_ formation-type) int 19)
|
|
(hover-formation-control-method-20 () none) ;; 20 ;; (hover-formation-control-method-20 (_type_ object object) none 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-formation (process)
|
|
((formation hover-formation-control :offset-assert 128) ;; guessed by decompiler
|
|
(path path-control :offset-assert 132) ;; guessed by decompiler
|
|
(formation-timer uint64 :offset-assert 136)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x90
|
|
:flag-assert #x1000100090
|
|
(:methods
|
|
(hover-formation-method-14 () none) ;; 14 ;; (idle () _type_ :state 14)
|
|
(hover-formation-method-15 () none) ;; 15 ;; (hover-formation-method-15 (_type_ vector vector) int 15)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-x-ride ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-x-ride (wcar-snake-base)
|
|
()
|
|
:method-count-assert 203
|
|
:size-assert #xd60
|
|
:flag-assert #xcb0ce00d60
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-util ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vehicle-hud-request (structure)
|
|
((handle uint64 :offset-assert 0) ;; handle
|
|
(hack-handle-init basic :offset-assert 0)
|
|
(priority float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-hud-requests (structure)
|
|
((time uint64 :offset-assert 0) ;; time-frame
|
|
(requests vehicle-hud-request 4 :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x48
|
|
:flag-assert #xc00000048
|
|
(:methods
|
|
(vehicle-hud-requests-method-9 () none) ;; 9 ;; (vehicle-hud-requests-method-9 (_type_) none 9)
|
|
(vehicle-hud-requests-method-10 () none) ;; 10 ;; (vehicle-hud-requests-method-10 (_type_) vehicle-hud-request 10)
|
|
(vehicle-hud-requests-method-11 () none) ;; 11 ;; (vehicle-hud-requests-method-11 (_type_) vehicle-hud-request 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-hud-chooser (structure)
|
|
((cur vehicle-hud-requests :inline :offset-assert 0)
|
|
(last vehicle-hud-requests :inline :offset-assert 72)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x90
|
|
:flag-assert #xa00000090
|
|
(:methods
|
|
(vehicle-hud-chooser-method-9 () none) ;; 9 ;; (vehicle-hud-chooser-method-9 (_type_ handle float) symbol 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *vehicle-hud-chooser* object) ;; vehicle-hud-chooser
|
|
;; (define-extern *pilot-edge-grab-info* object) ;; pilot-edge-grab-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; glist ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern glst-num-elements function) ;; (function glst-list int)
|
|
;; (define-extern glst-remove function) ;; (function glst-list glst-node glst-node)
|
|
;; (define-extern glst-remove-tail function) ;; (function glst-list glst-node)
|
|
;; (define-extern glst-remove-head function) ;; (function glst-list glst-node)
|
|
;; (define-extern glst-insert-before function) ;; (function glst-list glst-node glst-node glst-node)
|
|
;; (define-extern glst-insert-after function) ;; (function glst-list glst-node glst-node glst-node)
|
|
;; (define-extern glst-add-tail function) ;; (function glst-list glst-node glst-node)
|
|
;; (define-extern glst-add-head function) ;; (function glst-list glst-node glst-node)
|
|
;; (define-extern glst-init-list! function) ;; (function glst-list glst-list)
|
|
;; (define-extern glst-find-node-by-name function) ;; (function glst-list string glst-node)
|
|
;; (define-extern glst-get-node-by-index function) ;; (function glst-list int glst-node)
|
|
;; (define-extern glst-length-of-longest-name function) ;; (function glst-list int)
|
|
;; (define-extern glst-get-node-index function) ;; (function glst-list glst-node int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-shape ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern find-ground-point function) ;; (function control-info vector float float vector)
|
|
;; (define-extern target-attack-up function) ;; (function target symbol symbol none)
|
|
;; (define-extern collide-shape-moving-angle-set! function) ;; (function collide-shape-moving vector vector none)
|
|
;; (define-extern cshape-reaction-update-state function) ;; (function control-info collide-query vector none)
|
|
;; (define-extern cshape-reaction-default function) ;; (function control-info collide-query vector vector collide-status)
|
|
;; (define-extern cshape-reaction-just-move function) ;; (function control-info collide-query vector collide-status)
|
|
;; (define-extern collide-shape-draw-debug-marks function) ;; (function none)
|
|
;; (define-extern *col-timer* object) ;; stopwatch
|
|
;; (define-extern *frame-timer* object) ;; stopwatch
|
|
;; (define-extern *col-timer-enable* object) ;; symbol
|
|
;; (define-extern debug-report-col-stats function) ;; (function int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-shape-rider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-tube ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tube-info (basic)
|
|
((entity basic :offset-assert 4)
|
|
(tube uint64 :offset-assert 8) ;; handle
|
|
(downhill vector :inline :offset-assert 16)
|
|
(centertube vector :inline :offset-assert 32)
|
|
(downtube vector :inline :offset-assert 48)
|
|
(sidetube vector :inline :offset-assert 64)
|
|
(foretube vector :inline :offset-assert 80)
|
|
(old-transv vector :inline :offset-assert 96)
|
|
(mod-x float :offset-assert 112)
|
|
(mod-y float :offset-assert 116)
|
|
(start-time uint64 :offset-assert 120) ;; time-frame
|
|
(turn-anim-targ float :offset-assert 128)
|
|
(turn-anim-frame float :offset-assert 132)
|
|
(turn-anim-vel float :offset-assert 136)
|
|
(tube-sound-id sound-id :offset-assert 140) ;; guessed by decompiler
|
|
(tube-sound-vol float :offset-assert 144)
|
|
(tube-sound-pitch float :offset-assert 148)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x98
|
|
:flag-assert #x900000098
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tube-bank (basic)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype slide-control (process-drawable)
|
|
((target uint64 :offset-assert 200) ;; handle
|
|
(pos float :offset-assert 208)
|
|
(trans vector :inline :offset-assert 224)
|
|
(rot vector :inline :offset-assert 240)
|
|
(side vector :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x110
|
|
:flag-assert #x1600900110
|
|
(:state-methods
|
|
slide-control-watch ;; 20, old: (slide-control-watch () _type_ :state 20)
|
|
slide-control-ride ;; 21, old: (slide-control-ride () _type_ :state 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *tube-mods* surface) ;; surface
|
|
;; (define-extern *tube-jump-mods* surface) ;; surface
|
|
;; (define-extern *tube-hit-mods* surface) ;; surface
|
|
;; (define-extern *tube-surface* surface) ;; surface
|
|
;; (define-extern *TUBE-bank* tube-bank) ;; tube-bank
|
|
;; (define-extern tube-sounds function) ;; (function sound-id :behavior target)
|
|
;; (define-extern tube-thrust function) ;; (function float float none :behavior target)
|
|
;; (define-extern target-tube-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-tube-start object) ;; (state handle target)
|
|
;; (define-extern target-tube-turn-anim function) ;; (function none :behavior target)
|
|
;; (define-extern target-tube-walk object)
|
|
;; (define-extern target-tube-jump object) ;; (state float float target)
|
|
;; (define-extern target-tube-hit object) ;; (state symbol attack-info target)
|
|
;; (define-extern target-tube-death object) ;; (state symbol target)
|
|
;; (define-extern distance-from-tangent function) ;; (function path-control float vector vector vector vector float)
|
|
;; (define-extern find-target-point function) ;; (function vector float :behavior slide-control)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *collide-vif0-init* array) ;; (array uint32)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-hover ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-beast (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-hover (task-manager)
|
|
((vehicle-h uint64 :offset-assert 236)
|
|
(actor-group uint32 :offset-assert 244)
|
|
(actor-group-count int32 :offset-assert 248)
|
|
(end-time uint64 :offset-assert 252)
|
|
(hud-counter uint64 :offset-assert 204)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x110
|
|
:flag-assert #x2000900110
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; squad-control-city ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-engine ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-engine-spr-buffer (structure)
|
|
((mem-addr (pointer nav-mesh) :offset-assert 0) ;; guessed by decompiler
|
|
(mem-nav uint32 :offset-assert 0)
|
|
(spr-addr (inline-array nav-control) :offset-assert 4) ;; guessed by decompiler
|
|
(spr-nav uint32 :offset-assert 4)
|
|
(q-size uint32 :offset-assert 8)
|
|
(i-nav uint8 :offset-assert 12)
|
|
(done int8 :offset-assert 13)
|
|
(nav-count int8 :offset-assert 14)
|
|
(i-pass int8 :offset-assert 15)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-engine (structure)
|
|
((spr-addr uint32 :offset-assert 0)
|
|
(nav-work-addr uint32 :offset-assert 4)
|
|
(nav-mesh-addr nav-mesh :offset-assert 8) ;; guessed by decompiler
|
|
(poly-array-addr uint32 :offset-assert 12)
|
|
(hash-sphere-addr uint32 :offset-assert 16)
|
|
(hash-buckets-addr uint32 :offset-assert 20)
|
|
(buf-nav-control-count int8 :offset-assert 24)
|
|
(max-pass-count int8 :offset-assert 25)
|
|
(output-sphere-hash uint8 :offset-assert 26)
|
|
(work-buf-array nav-engine-spr-buffer 3 :offset-assert 28) ;; guessed by decompiler
|
|
(spr-work nav-mesh-work :offset-assert 4)
|
|
(mem-work nav-mesh-work :offset-assert 76)
|
|
(spr-mesh nav-mesh :offset-assert 8) ;; guessed by decompiler
|
|
(mem-mesh nav-mesh :offset-assert 80) ;; guessed by decompiler
|
|
(spr-poly-array uint32 :offset-assert 12)
|
|
(mem-poly-array (inline-array nav-poly) :offset-assert 84) ;; guessed by decompiler
|
|
(hash-sphere-list uint32 :offset-assert 16)
|
|
(hash-buckets uint32 :offset-assert 20)
|
|
(to-spr-wait uint32 :offset-assert 88)
|
|
(from-spr-wait uint32 :offset-assert 92)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x60
|
|
:flag-assert #x1600000060
|
|
(:methods
|
|
(nav-engine-method-9 () none) ;; 9 ;; (inc-spr-addr! (_type_ uint) uint 9)
|
|
(nav-engine-method-10 () none) ;; 10 ;; (lay-out-spad-memory (_type_ nav-mesh) none 10)
|
|
(nav-engine-method-11 () none) ;; 11 ;; (set-up-mem-work (_type_) none 11)
|
|
(nav-engine-method-12 () none) ;; 12 ;; (add-spheres-from-mesh-user-list (_type_ sphere-hash nav-mesh) none 12)
|
|
(nav-engine-method-13 () none) ;; 13 ;; (add-all-spheres (_type_) none 13)
|
|
(nav-engine-method-14 () none) ;; 14 ;; (do-sphere-lookups (_type_) none 14)
|
|
(nav-engine-method-15 () none) ;; 15 ;; (update-nav-controls-pipelined-in-spr (_type_) none 15)
|
|
(nav-engine-method-16 () none) ;; 16 ;; (update-nav-controls-in-spr (_type_) none 16)
|
|
(nav-engine-method-17 () none) ;; 17 ;; (upload-nav-to-spr (_type_ nav-engine-spr-buffer) none 17)
|
|
(nav-engine-method-18 () none) ;; 18 ;; (download-nav-from-spr (_type_ nav-engine-spr-buffer) none 18)
|
|
(nav-engine-method-19 () none) ;; 19 ;; (do-callbacks (_type_ nav-engine-spr-buffer) none 19)
|
|
(nav-engine-method-20 () none) ;; 20 ;; (reloc-ptrs-to-spad (_type_ nav-engine-spr-buffer) none 20)
|
|
(nav-engine-method-21 () none) ;; 21 ;; (reloc-ptrs-to-mem (_type_ nav-engine-spr-buffer) none 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern nav-dma-send-to-spr-no-flush function) ;; (function pointer pointer int none)
|
|
;; (define-extern nav-dma-send-from-spr-no-flush function) ;; (function pointer pointer int none)
|
|
;; (define-extern inc-mod3 function) ;; (function int int)
|
|
;; (define-extern nav-state-patch-pointers function) ;; (function nav-state int none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-planes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern collide-planes-intersect function)
|
|
;; (define-extern collide-planes-test0 function)
|
|
;; (define-extern collide-planes-test1 function)
|
|
;; (define-extern collide-planes function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; spatial-hash ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype grid-hash-work (basic)
|
|
((result-words uint8 32 :offset-assert 16) ;; guessed by decompiler
|
|
(result-bits uint8 32 :offset-assert 16) ;; guessed by decompiler
|
|
(object-id int32 :offset-assert 48)
|
|
(temp-box-min vector :inline :offset-assert 64)
|
|
(temp-box-max vector :inline :offset-assert 80)
|
|
(visit-count int32 :offset-assert 96)
|
|
(temp-time uint32 :offset-assert 100)
|
|
(queue-object-time uint32 :offset-assert 104)
|
|
(make-hash-time uint32 :offset-assert 108)
|
|
(search-time uint32 :offset-assert 112)
|
|
(add-object-time uint32 :offset-assert 116)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x78
|
|
:flag-assert #x900000078
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *grid-hash-work* grid-hash-work) ;; grid-hash-work
|
|
;; (define-extern validate-bucket-bits function) ;; (function grid-hash (pointer grid-hash-word) symbol)
|
|
;; (define-extern draw-grid function) ;; (function vector vector (pointer int8) rgba none)
|
|
;; (define-extern draw-sphere-box function) ;; (function sphere rgba none)
|
|
;; (define-extern draw-line-sphere function) ;; (function vector vector float rgba none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sewer-move-turret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sew-move-turret (process-drawable)
|
|
((sound-id uint32 :offset-assert 200)
|
|
(use-doppler? basic :offset-assert 204)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd0
|
|
:flag-assert #x17005000d0
|
|
(:methods
|
|
(sew-move-turret-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-move-turret-shot (guard-shot)
|
|
((doppler-sound uint32 :offset-assert 544)
|
|
(use-doppler? basic :offset-assert 548)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x228
|
|
:flag-assert #x2901b00228
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sew-turret-shot-move function)
|
|
;; (define-extern spawn-sew-move-turret-projectile function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; actor-hash ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype actor-cshape-ptr (structure)
|
|
((cshape collide-shape :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype actor-hash-bucket (structure)
|
|
((length int16 :offset-assert 0)
|
|
(max-length int16 :offset-assert 2)
|
|
(data (inline-array actor-cshape-ptr) :offset-assert 4) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x8
|
|
:flag-assert #xa00000008
|
|
(:methods
|
|
(actor-hash-bucket-method-9 () none) ;; 9 ;; (add-actor-cshape (_type_ collide-shape) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype actor-hash-buckets (structure)
|
|
((hash spatial-hash :offset-assert 0) ;; guessed by decompiler
|
|
(list engine :offset-assert 4) ;; guessed by decompiler
|
|
(data actor-hash-bucket 4 :offset-assert 8) ;; guessed by decompiler
|
|
(tpos vector :inline :offset-assert 80)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x60
|
|
:flag-assert #xa00000060
|
|
(:methods
|
|
(actor-hash-buckets-method-9 () none) ;; 9 ;; (hash-actors (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *actor-hash* object) ;; spatial-hash
|
|
;; (define-extern *actor-hash-buckets* object) ;; actor-hash-buckets
|
|
;; (define-extern update-actor-hash function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; templea-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *templea-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *templea-warp-texture-anim-array* texture-anim-array)
|
|
;; (define-extern templea-warp-texture-anim-func function)
|
|
;; (define-extern *templeb-warp-texture-anim-array* texture-anim-array)
|
|
;; (define-extern templeb-warp-texture-anim-func function)
|
|
;; (define-extern *templec-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; merc-death ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *merc-death-globals* object) ;; vector
|
|
;; (define-extern birth-func-death-sparks function) ;; (function none)
|
|
;; (define-extern death-seed death-info) ;; death-info
|
|
;; (define-extern start-seed-effect function) ;; (function process-drawable vector cspace none)
|
|
;; (define-extern death-default death-info) ;; death-info
|
|
;; (define-extern death-warp-in death-info) ;; death-info
|
|
;; (define-extern death-warp-out death-info) ;; death-info
|
|
;; (define-extern sparticle-texture-glow-soft function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern merc-death-spawn function) ;; (function int vector vector none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; camera ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cam-slave-get-vector-with-offset function) ;; (function entity-actor vector symbol symbol)
|
|
;; (define-extern cam-slave-get-flags function) ;; (function entity symbol uint)
|
|
;; (define-extern cam-slave-get-float function) ;; (function entity symbol float float)
|
|
;; (define-extern cam-slave-get-fov function) ;; (function entity float)
|
|
;; (define-extern cam-slave-get-intro-step function) ;; (function entity float)
|
|
;; (define-extern cam-slave-get-interp-time function) ;; (function entity float)
|
|
;; (define-extern cam-slave-get-rot function) ;; (function entity-actor matrix matrix)
|
|
;; (define-extern cam-state-from-entity function) ;; (function entity (state camera-slave))
|
|
;; (define-extern parameter-ease-none function) ;; (function object object)
|
|
;; (define-extern parameter-ease-clamp function) ;; (function float float)
|
|
;; (define-extern parameter-ease-lerp-clamp function) ;; (function float float)
|
|
;; (define-extern parameter-ease-sqrt-clamp function) ;; (function float float)
|
|
;; (define-extern fourth-power function) ;; (function float float)
|
|
;; (define-extern third-power function) ;; (function float float)
|
|
;; (define-extern parameter-ease-sqr-clamp function) ;; (function float float)
|
|
;; (define-extern parameter-ease-cube-clamp function) ;; (function float float)
|
|
;; (define-extern parameter-ease-sin-clamp function) ;; (function float float)
|
|
;; (define-extern *cam-res-string* object) ;; string
|
|
;; (define-extern cam-slave-init-vars function) ;; (function none :behavior camera-slave)
|
|
;; (define-extern cam-slave-go function) ;; (function (state camera-slave) none :behavior camera-slave)
|
|
;; (define-extern cam-slave-init function) ;; (function (state camera-slave) entity none :behavior camera-slave)
|
|
;; (define-extern cam-standard-event-handler function) ;; (function process int symbol event-message-block object :behavior camera-slave)
|
|
;; (define-extern cam-curve-pos function) ;; (function vector vector curve symbol vector :behavior camera-slave)
|
|
;; (define-extern cam-curve-setup function) ;; (function vector none :behavior camera-slave)
|
|
;; (define-extern cam-calc-follow! function) ;; (function cam-rotation-tracker vector symbol vector)
|
|
;; (define-extern mat-remove-z-rot function) ;; (function matrix vector matrix)
|
|
;; (define-extern slave-matrix-blend-2 function) ;; (function matrix cam-slave-options-u32 vector matrix matrix)
|
|
;; (define-extern vector-into-frustum-nosmooth! function) ;; (function matrix vector float vector)
|
|
;; (define-extern slave-set-rotation! function) ;; (function cam-rotation-tracker vector cam-slave-options-u32 float symbol none)
|
|
;; (define-extern v-slrp2! function) ;; (function vector vector vector float vector float vector)
|
|
;; (define-extern v-slrp3! function) ;; (function vector vector vector vector float vector)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; board-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype board (process-drawable)
|
|
((control control-info :offset-assert 128) ;; guessed by decompiler
|
|
(shadow-backup shadow-geo :offset-assert 208) ;; guessed by decompiler
|
|
(main joint-mod :offset-assert 212) ;; guessed by decompiler
|
|
(in-head-time uint64 :offset-assert 216)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xe0
|
|
:flag-assert #x17006000e0
|
|
(:methods
|
|
(board-method-20 () none) ;; 20 ;; (idle (symbol) _type_ :state 20)
|
|
(board-method-21 () none) ;; 21 ;; (use () _type_ :state 21)
|
|
(board-method-22 () none) ;; 22 ;; (hidden () _type_ :state 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype board-info (basic)
|
|
((board (pointer board) :offset-assert 4) ;; guessed by decompiler
|
|
(camera-interp float :offset-assert 8)
|
|
(process (pointer target) :offset-assert 12) ;; guessed by decompiler
|
|
(board-trans vector :inline :offset-assert 16)
|
|
(board-quat vector :inline :offset-assert 32)
|
|
(board-scale vector :inline :offset-assert 48)
|
|
(main joint-mod :offset-assert 64) ;; guessed by decompiler
|
|
(upper-body joint-mod :offset-assert 68) ;; guessed by decompiler
|
|
(sound-bank-knob float :offset-assert 76)
|
|
(sound-air-knob float :offset-assert 80)
|
|
(wind-sound-id sound-id :offset-assert 84) ;; guessed by decompiler
|
|
(wind-sound-pitch float :offset-assert 88)
|
|
(wind-sound-volume float :offset-assert 92)
|
|
(engine-sound-id sound-id :offset-assert 96) ;; guessed by decompiler
|
|
(engine-sound-pitch float :offset-assert 100)
|
|
(engine-sound-volume float :offset-assert 104)
|
|
(bank-sound-id sound-id :offset-assert 108) ;; guessed by decompiler
|
|
(bank-sound-pitch float :offset-assert 112)
|
|
(bank-sound-volume float :offset-assert 116)
|
|
(ride-sound-id sound-id :offset-assert 120) ;; guessed by decompiler
|
|
(spin-sound-id sound-id :offset-assert 124) ;; guessed by decompiler
|
|
(spin-sound-volume float :offset-assert 128)
|
|
(spin-sound-pitch float :offset-assert 132)
|
|
(up-vector vector 2 :offset-assert 176) ;; guessed by decompiler
|
|
(slow-transv vector :inline :offset-assert 208)
|
|
(board-time uint64 :offset-assert 224) ;; time-frame
|
|
(board-get-on-time uint64 :offset-assert 232) ;; time-frame
|
|
(in-air-time uint64 :offset-assert 240) ;; time-frame
|
|
(stick-lock symbol :offset-assert 272) ;; guessed by decompiler
|
|
(stick-off symbol :offset-assert 276) ;; guessed by decompiler
|
|
(stance-info ground-tween-info :inline :offset-assert 280)
|
|
(mods-backup basic :offset-assert 316)
|
|
(attack-id uint32 :offset-assert 320)
|
|
(latch? symbol :offset-assert 324) ;; guessed by decompiler
|
|
(unstuck-time uint64 :offset-assert 376) ;; time-frame
|
|
(stuck-count int32 :offset-assert 384)
|
|
(thrust-scale float :offset-assert 388)
|
|
(flip-time uint64 :offset-assert 392) ;; time-frame
|
|
(transv-max meters :offset-assert 400)
|
|
(turn-anim-tilt? symbol :offset-assert 404) ;; guessed by decompiler
|
|
(turn-anim-mag float :offset-assert 408)
|
|
(turn-anim-targ float :offset-assert 412)
|
|
(turn-anim-frame float :offset-assert 416)
|
|
(turn-anim-vel float :offset-assert 428)
|
|
(turn-anim-duck float :offset-assert 432)
|
|
(turn-anim-duck-vel float :offset-assert 436)
|
|
(tilt-anim-frame vector :inline :offset-assert 448)
|
|
(tilt-anim-targ vector :inline :offset-assert 464)
|
|
(smack-surface-time uint64 :offset-assert 480) ;; time-frame
|
|
(smack-speed meters :offset-assert 488)
|
|
(smack-normal vector :inline :offset-assert 496)
|
|
(glance-time uint64 :offset-assert 512) ;; time-frame
|
|
(glance-speed meters :offset-assert 520)
|
|
(glance-in-transv vector :inline :offset-assert 528)
|
|
(glance-out-transv vector :inline :offset-assert 544)
|
|
(glance-normal vector :inline :offset-assert 560)
|
|
(on-flat-time uint64 :offset-assert 576) ;; time-frame
|
|
(jump-land-time uint64 :offset-assert 584) ;; time-frame
|
|
(slip-factor float :offset-assert 592)
|
|
(ground-on-dir vector :inline :offset-assert 608)
|
|
(ride-time uint64 :offset-assert 624) ;; time-frame
|
|
(ride-start-time uint64 :offset-assert 632) ;; time-frame
|
|
(ride-button-time uint64 :offset-assert 640) ;; time-frame
|
|
(ride-lean-targ float :offset-assert 648)
|
|
(ride-lean float :offset-assert 652)
|
|
(ride-leanv float :offset-assert 656)
|
|
(ride-lean-mag float :offset-assert 660)
|
|
(ride-tilt-targ float :offset-assert 664)
|
|
(ride-tilt float :offset-assert 668)
|
|
(ride-tiltv float :offset-assert 672)
|
|
(ride-tilt-mag float :offset-assert 676)
|
|
(ride-lock symbol :offset-assert 680) ;; guessed by decompiler
|
|
(ride-lock-on symbol :offset-assert 684) ;; guessed by decompiler
|
|
(ride-speed meters :offset-assert 688)
|
|
(ride-mode uint32 :offset-assert 692)
|
|
(ride-rot deg :offset-assert 696) ;; degrees
|
|
(ride-rot-old deg :offset-assert 700) ;; degrees
|
|
(ride-rot-abs degrees 2 :offset-assert 704) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(ride-rotv-abs deg :offset-assert 712)
|
|
(ride-touch-segment vector 2 :offset-assert 720) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(ride-dir vector :inline :offset-assert 752)
|
|
(ride-vertex-length int16 :offset-assert 768)
|
|
(ride-vertex-length-old int16 :offset-assert 770)
|
|
(ride-vertex-base int16 :offset-assert 772)
|
|
(ride-vertex-base2 int16 :offset-assert 774)
|
|
(ride-vertex-index float :offset-assert 776)
|
|
(ride-vertex-index2 float :offset-assert 780)
|
|
(ride-vertex-index-old float :offset-assert 784)
|
|
(ride-vertex vector 3 :offset-assert 800) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(ride-segment vector :inline :offset-assert 848)
|
|
(ride-dir-lean vector :inline :offset-assert 864)
|
|
(ride-pad-vector vector 1 :offset-assert 880) ;; guessed by decompiler
|
|
(ride-vertex-old vector 3 :offset-assert 896) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(ride-segment-old vector :inline :offset-assert 944)
|
|
(ride-vertex-trail vector 128 :offset-assert 960) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(halfpipe-side-time uint64 :offset-assert 3008) ;; time-frame
|
|
(halfpipe-jump-time uint64 :offset-assert 3016) ;; time-frame
|
|
(halfpipe-lip-time uint64 :offset-assert 3024) ;; time-frame
|
|
(halfpipe-time uint64 :offset-assert 3032) ;; time-frame
|
|
(halfpipe-gspot-time uint64 :offset-assert 3040) ;; time-frame
|
|
(halfpipe-lip-event symbol :offset-assert 3048) ;; guessed by decompiler
|
|
(spin-check-time uint64 :offset-assert 3056) ;; time-frame
|
|
(spin-time uint64 :offset-assert 3064) ;; time-frame
|
|
(spin-start-time uint64 :offset-assert 3072) ;; time-frame
|
|
(spin-start-dir vector :inline :offset-assert 3088)
|
|
(spin-control float :offset-assert 3104)
|
|
(spin-ground-start-time uint64 :offset-assert 3112) ;; time-frame
|
|
(spin-ground-time uint64 :offset-assert 3120) ;; time-frame
|
|
(spin-ground-press-time uint64 :offset-assert 3128) ;; time-frame
|
|
(flip-control float :offset-assert 3136)
|
|
(flip-count int32 :offset-assert 3140)
|
|
(trickx-count int32 :offset-assert 3196)
|
|
(rotyv-max deg :offset-assert 3240)
|
|
(rotyv deg :offset-assert 3244)
|
|
(roty deg :offset-assert 3248)
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(upper-body-rotyv-max deg :offset-assert 3260) ;; degrees
|
|
(upper-body-rotyv deg :offset-assert 3264) ;; degrees
|
|
(upper-body-roty deg :offset-assert 3268) ;; degrees
|
|
(cushion-base meters :offset-assert 3272)
|
|
(cushion-offset meters :offset-assert 3276)
|
|
(shock-offset meters :offset-assert 3280)
|
|
(shock-offsetv meters :offset-assert 3284)
|
|
(shock-rotx meters :offset-assert 3288)
|
|
(trick-count int32 :offset-assert 3300)
|
|
(zap-start-time uint64 :offset-assert 3520)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #xdc8
|
|
:flag-assert #xb00000dc8
|
|
(:methods
|
|
(board-info-method-9 () none) ;; 9 ;; (add-to-trick-list (_type_ board-tricks float) none 9)
|
|
(board-info-method-10 () none) ;; 10 ;; (flush-trick-list (_type_) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype target-board-bank (basic)
|
|
((jump-height-min meters :offset-assert 4)
|
|
(jump-height-max meters :offset-assert 8)
|
|
(duck-jump-height-min meters :offset-assert 12)
|
|
(duck-jump-height-max meters :offset-assert 16)
|
|
(turn-frames float :offset-assert 20)
|
|
(wall-kick-window seconds :offset-assert 24)
|
|
(cushion meters :offset-assert 32)
|
|
(trickx-jump-height-min meters :offset-assert 36)
|
|
(trickx-jump-height-max meters :offset-assert 40)
|
|
(tricky-jump-height-min meters :offset-assert 44)
|
|
(tricky-jump-height-max meters :offset-assert 48)
|
|
(trickz-jump-height-min meters :offset-assert 52)
|
|
(trickz-jump-height-max meters :offset-assert 56)
|
|
(charge-jump-time seconds :offset-assert 64)
|
|
(charge-jump-fade-time seconds :offset-assert 72)
|
|
(charge-jump-height meters :offset-assert 80)
|
|
(zap-duration uint64 :offset-assert 88)
|
|
(zap-reset-time uint64 :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x68
|
|
:flag-assert #x900000068
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *TARGET_BOARD-bank* target-board-bank) ;; target-board-bank
|
|
;; (define-extern want-to-board? function) ;; (function symbol :behavior target)
|
|
;; (define-extern *board-shadow-control* shadow-control) ;; shadow-control
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-interface ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern position-in-front-of-camera! function) ;; (function vector float float vector)
|
|
;; (define-extern position-in-front-of-screen! function) ;; (function vector float vector vector)
|
|
;; (define-extern matrix-local->world function) ;; (function symbol symbol matrix)
|
|
;; (define-extern matrix-world->local function) ;; (function symbol object matrix)
|
|
;; (define-extern *camera-dummy-vector* object) ;; vector
|
|
;; (define-extern camera-pos function) ;; (function vector)
|
|
;; (define-extern math-camera-pos function) ;; (function vector)
|
|
;; (define-extern camera-matrix function) ;; (function matrix)
|
|
;; (define-extern math-camera-matrix function) ;; (function matrix)
|
|
;; (define-extern camera-angle function) ;; (function float)
|
|
;; (define-extern camera-teleport-to-entity function) ;; (function entity-actor symbol :behavior process)
|
|
;; (define-extern camera-teleport-to-entity-named function)
|
|
;; (define-extern camera-teleport-to-location function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fac-robotank-turret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fac-robotank-turret (process-focusable)
|
|
((los los-control :inline :offset-assert 208)
|
|
(tank-quat quaternion :inline :offset-assert 384)
|
|
(tank-quat-vibe-only quaternion :inline :offset-assert 400)
|
|
(rotate-quat quaternion :inline :offset-assert 416)
|
|
(rotate-rate float :offset-assert 432)
|
|
(rotate-mult float :offset-assert 436)
|
|
(shot-range float :offset-assert 440)
|
|
(fov-mult float :offset-assert 444)
|
|
(offset vector :inline :offset-assert 448)
|
|
(sight-pos vector :inline :offset-assert 464)
|
|
(firing-sight-pos vector :inline :offset-assert 480)
|
|
(aim-pos UNKNOWN 3 :offset-assert 496)
|
|
(gun-timer uint64 :offset-assert 544)
|
|
(gun-elev-jmod basic :offset-assert 552)
|
|
(gun-elev float :offset-assert 556)
|
|
(gun-elev-cam float :offset-assert 560)
|
|
(gun-joint-l UNKNOWN 2 :offset-assert 564)
|
|
(gun-joint-r UNKNOWN 2 :offset-assert 572)
|
|
(gun-spread float :offset-assert 580)
|
|
(gun-index int32 :offset-assert 584)
|
|
(flags uint16 :offset-assert 588)
|
|
(turn-sound-id uint32 :offset-assert 592)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x254
|
|
:flag-assert #x2301e00254
|
|
(:methods
|
|
(fac-robotank-turret-method-31 () none) ;; 31
|
|
(fac-robotank-turret-method-32 () none) ;; 32
|
|
(fac-robotank-turret-method-33 () none) ;; 33
|
|
(fac-robotank-turret-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
ready ;; 28
|
|
fire ;; 29
|
|
die ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robotank-reticle (process-drawable)
|
|
((shadow-jmod joint-mod-set-local :offset-assert 200)
|
|
(sight-jmod joint-mod-set-local :offset-assert 204)
|
|
(ring-jmod UNKNOWN 3 :offset-assert 208)
|
|
(ring-timer uint64 :offset-assert 224)
|
|
(sight-scale vector :inline :offset-assert 240)
|
|
(collide-dist float :offset-assert 256)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x104
|
|
:flag-assert #x1600900104
|
|
(:methods
|
|
(fac-robotank-reticle-method-20 () none) ;; 20
|
|
(fac-robotank-reticle-method-21 () none) ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern fac-robotank-reticle-post function)
|
|
;; (define-extern fac-robotank-reticle-handler function)
|
|
;; (define-extern draw-2d-hud function) ;; (function vector symbol)
|
|
;; (define-extern turret-post function) ;; (function none :behavior fort-robotank-turret)
|
|
;; (define-extern robotank-turret-handler function) ;; (function process int symbol event-message-block object :behavior fort-robotank-turret)
|
|
;; (define-extern fac-robotank-turret-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-master ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern reset-follow function) ;; (function float :behavior camera-master)
|
|
;; (define-extern reset-target-tracking function) ;; (function symbol :behavior camera-master)
|
|
;; (define-extern master-track-target function) ;; (function symbol :behavior camera-master)
|
|
;; (define-extern setup-slave-for-hopefull function) ;; (function camera-slave none)
|
|
;; (define-extern master-is-hopeful-better? function) ;; (function camera-slave camera-slave symbol :behavior camera-master)
|
|
;; (define-extern master-choose-entity function) ;; (function cam-setting-data symbol :behavior camera-master)
|
|
;; (define-extern cam-master-set-entity function) ;; (function cam-setting-data none)
|
|
;; (define-extern cam-master-activate-slave function) ;; (function symbol none)
|
|
;; (define-extern cam-master-active state) ;; (state camera-master)
|
|
;; (define-extern cam-master-init function) ;; (function none :behavior camera-master)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-combiner ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cam-helper-temp function) ;; (function (pointer camera-slave) (pointer camera-slave) float matrix :behavior camera-combiner)
|
|
;; (define-extern cam-combiner-active state) ;; (state camera-combiner)
|
|
;; (define-extern cam-combiner-init function) ;; (function none :behavior camera-combiner)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-debug ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cam-dbg-scratch (structure)
|
|
((linevec4w vector :inline :offset-assert 0) ;; vector4w 2 :inline
|
|
(color vector :inline :offset-assert 32) ;; vector4w :inline
|
|
(plotvec vector :inline :offset-assert 48) ;; vector4w 2 :inline
|
|
(linevec vector :inline :offset-assert 80) ;; vector4w 2 :inline
|
|
(rel-vec vector :inline :offset-assert 112)
|
|
(sphere-v-start vector :inline :offset-assert 128)
|
|
(sphere-v-end vector :inline :offset-assert 144)
|
|
(sphere-v-down vector :inline :offset-assert 160)
|
|
(sphere-vec vector :inline :offset-assert 176)
|
|
(crossvec vector :inline :offset-assert 192)
|
|
(bboxvec vector :inline :offset-assert 240)
|
|
(fov-vv vector :inline :offset-assert 336)
|
|
(fov-src vector :inline :offset-assert 400)
|
|
(fov-dest vector :inline :offset-assert 416)
|
|
(fov-vert vector :inline :offset-assert 432)
|
|
(fov-horz vector :inline :offset-assert 448)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1d0
|
|
:flag-assert #x9000001d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-debug-tri (structure)
|
|
((vertex vector 3 :offset-assert 0) ;; guessed by decompiler
|
|
(intersect vector :inline :offset-assert 48)
|
|
(color vector4w :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-collision-record (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(vel vector :inline :offset-assert 16)
|
|
(desired-pos vector :inline :offset-assert 32)
|
|
(cam-tpos-cur vector :inline :offset-assert 48)
|
|
(cam-tpos-old vector :inline :offset-assert 64)
|
|
(view-flat vector :inline :offset-assert 80)
|
|
(string-min-val vector :inline :offset-assert 96)
|
|
(string-max-val vector :inline :offset-assert 112)
|
|
(view-off vector :inline :offset-assert 128)
|
|
(min-z-override float :offset-assert 144)
|
|
(string-push-z float :offset-assert 148)
|
|
(view-off-param float :offset-assert 152)
|
|
(frame int32 :offset-assert 156)
|
|
(iteration int32 :offset-assert 160)
|
|
(move-type symbol :offset-assert 164) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa8
|
|
:flag-assert #x9000000a8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-collision-record-array (inline-array-class)
|
|
((data cam-collision-record :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *camera-old-cpu* object) ;; int
|
|
;; (define-extern *camera-old-vu* object) ;; int
|
|
;; (define-extern *camera-old-tfrag-bytes* object) ;; int
|
|
;; (define-extern *camera-old-level* object) ;; string
|
|
;; (define-extern *camera-old-stat-string-tfrag* object) ;; string
|
|
;; (define-extern *camera-old-stat-string-tfrag-near* object) ;; string
|
|
;; (define-extern *camera-old-stat-string-total* object) ;; string
|
|
;; (define-extern cam-slave-options->string function) ;; (function cam-slave-options object string)
|
|
;; (define-extern cam-index-options->string function) ;; (function cam-index-options object string)
|
|
;; (define-extern slave-los-state->string function) ;; (function slave-los-state string)
|
|
;; (define-extern cam-line-dma function) ;; (function pointer)
|
|
;; (define-extern camera-line2d function) ;; (function vector4w vector4w pointer)
|
|
;; (define-extern camera-plot-float-func function) ;; (function float float float float (function float float) vector4w none)
|
|
;; (define-extern camera-line-setup function) ;; (function vector4w none)
|
|
;; (define-extern camera-line-draw function) ;; (function vector vector none)
|
|
;; (define-extern camera-line function) ;; (function vector vector vector4w none)
|
|
;; (define-extern camera-line-rel function) ;; (function vector vector vector4w none)
|
|
;; (define-extern camera-line-rel-len function) ;; (function vector vector float vector4w none)
|
|
;; (define-extern camera-sphere function) ;; (function vector float vector4w none)
|
|
;; (define-extern camera-cross function) ;; (function vector vector vector vector4w meters none)
|
|
;; (define-extern camera-bounding-box-draw function) ;; (function bounding-box basic rgba none)
|
|
;; (define-extern *cam-debug-los-tri-current* object) ;; int
|
|
;; (define-extern *cam-debug-los-tri* object) ;; (inline-array cam-debug-tri)
|
|
;; (define-extern *cam-debug-coll-tri-current* object) ;; int
|
|
;; (define-extern *cam-debug-coll-tri* object) ;; (inline-array cam-debug-tri)
|
|
;; (define-extern cam-debug-reset-coll-tri function) ;; (function none)
|
|
;; (define-extern cam-debug-add-los-tri function) ;; (function (inline-array collide-cache-tri) vector vector none)
|
|
;; (define-extern cam-debug-add-coll-tri function) ;; (function cam-debug-tri vector cam-debug-tri none)
|
|
;; (define-extern cam-debug-draw-tris function) ;; (function symbol)
|
|
;; (define-extern camera-fov-draw function) ;; (function int int vector float float vector4w none)
|
|
;; (define-extern camera-fov-frame function) ;; (function matrix vector float float float vector4w symbol)
|
|
;; (define-extern debug-euler function) ;; (function cam-dbg-scratch object)
|
|
;; (define-extern bike-cam-limit function) ;; (function float float)
|
|
;; (define-extern camera-slave-debug function) ;; (function camera-slave none)
|
|
;; (define-extern master-draw-coordinates function) ;; (function vector none)
|
|
;; (define-extern *cam-collision-record-first* object) ;; int
|
|
;; (define-extern *cam-collision-record-last* object) ;; int
|
|
;; (define-extern *cam-collision-record-show* object) ;; int
|
|
;; (define-extern *cam-collision-record* object) ;; cam-collision-record-array
|
|
;; (define-extern cam-collision-record-save function) ;; (function vector vector int symbol camera-slave none)
|
|
;; (define-extern cam-collision-record-step function) ;; (function int none)
|
|
;; (define-extern cam-collision-record-draw function) ;; (function none)
|
|
;; (define-extern camera-master-debug function) ;; (function camera-master none)
|
|
;; (define-extern debug-set-camera-pos-rot! function) ;; (function vector matrix vector)
|
|
;; (define-extern cam-restore function) ;; (function none)
|
|
;; (define-extern cam-restore-generic-bug function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; indax-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype indax-info (basic)
|
|
((indax-start-time uint64 :offset-assert 8) ;; time-frame
|
|
(indax-time uint64 :offset-assert 16) ;; time-frame
|
|
(indax-hang-start-time uint64 :offset-assert 24)
|
|
(art-group-backup art-group :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; eye ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *eye-work* object) ;; eye-work
|
|
;; (define-extern find-free-eye-index function)
|
|
;; (define-extern free-eye-index function)
|
|
;; (define-extern render-eyes-32 function) ;; (function dma-buffer eye-control int pointer)
|
|
;; (define-extern render-eyes-64 function) ;; (function dma-buffer eye-control int pointer)
|
|
;; (define-extern debug-eyes function) ;; (function dma-buffer none)
|
|
;; (define-extern update-eyes function) ;; (function none)
|
|
;; (define-extern get-eye-block function) ;; (function int int int)
|
|
;; (define-extern convert-eye-data function) ;; (function eye uint float)
|
|
;; (define-extern merc-eye-anim function) ;; (function process-drawable none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hiphog-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hiphog-mirror-wf-pt (structure)
|
|
((x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern part-hiphog-sphere-vert-line-flicker function)
|
|
;; (define-extern birth-func-hiphog-sphere function)
|
|
;; (define-extern birth-func-rotate-minute function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern birth-func-rotate-hour function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern birth-func-rotate-second function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
;; (define-extern *hiphog-mirror-sheen-waveform* object) ;; (inline-array ripple-wave)
|
|
;; (define-extern hiphog-mirror-sheen-func function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vol ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern plane-volume-intersect-dist function) ;; (function vector vector vector float)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gungame-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *lgunnorm-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cam-start ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cam-stop function) ;; (function symbol)
|
|
;; (define-extern cam-start function) ;; (function symbol none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cloth-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype stick-constraint (structure)
|
|
((constraint-length-half float :offset-assert 0)
|
|
(one-over-two-times-constraint-length float :offset-assert 4)
|
|
(constraint-length-sqd float :offset-assert 8)
|
|
(particle0 uint16 :offset-assert 12)
|
|
(particle1 uint16 :offset-assert 14)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype verlet-particle (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(prev-pos vector :inline :offset-assert 16)
|
|
(mass-scale float :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype disc-constraint (structure)
|
|
((normal vector :inline :offset-assert 0)
|
|
(origin vector :inline :offset-assert 16)
|
|
(radius float :offset-assert 32)
|
|
(start-particle-index int16 :offset-assert 36)
|
|
(end-particle-index int16 :offset-assert 38)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cylinder-constraint (structure)
|
|
((c0 vector :inline :offset-assert 0)
|
|
(norm vector :inline :offset-assert 16)
|
|
(length float :offset-assert 32)
|
|
(radius float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype particle-anchor-point (structure)
|
|
((anchor-pos vector :inline :offset-assert 0)
|
|
(particle-index uint16 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x12
|
|
:flag-assert #x900000012
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype particle-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype float-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype stick-constraint-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collision-sphere-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collision-disc-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collision-cylinder-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype anchor-point-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype verlet-particle-system (cloth-base)
|
|
((particles basic :offset-assert 4)
|
|
(drag float :offset-assert 8)
|
|
(accum-force vector :inline :offset-assert 16)
|
|
(timestep-frequency int8 :offset-assert 32)
|
|
(last-simulate-remaining int8 :offset-assert 33)
|
|
(momentum vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x40
|
|
:flag-assert #x1000000040
|
|
(:methods
|
|
(verlet-particle-system-method-11 () none) ;; 11
|
|
(verlet-particle-system-method-12 () none) ;; 12
|
|
(verlet-particle-system-method-13 () none) ;; 13
|
|
(verlet-particle-system-method-14 () none) ;; 14
|
|
(verlet-particle-system-method-15 () none) ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype current-position-info (structure)
|
|
((current-vert-index uint16 :offset-assert 0)
|
|
(last-2-x-index uint16 :offset-assert 2)
|
|
(last-2-y-index uint16 :offset-assert 4)
|
|
(last-x-index uint16 :offset-assert 6)
|
|
(last-y-index uint16 :offset-assert 8)
|
|
(lights vu-lights :inline :offset-assert 16)
|
|
(scale vector :inline :offset-assert 128)
|
|
(clamp-col vector :inline :offset-assert 144)
|
|
(last-normal vector :inline :offset-assert 160)
|
|
(face-normal-needs-flip? basic :offset-assert 176)
|
|
(cross-index0 int8 :offset-assert 180)
|
|
(cross-index1 int8 :offset-assert 181)
|
|
(backside-normal vector :inline :offset-assert 192)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xd0
|
|
:flag-assert #x9000000d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cloth-system (verlet-particle-system)
|
|
((particles basic :offset-assert 0)
|
|
(drag float :offset-assert 4)
|
|
(accum-force vector :inline :offset-assert 12)
|
|
(timestep-frequency int8 :offset-assert 28)
|
|
(last-simulate-remaining int8 :offset-assert 29)
|
|
(momentum vector :inline :offset-assert 44)
|
|
(ground-constraint float :offset-assert 60)
|
|
(disc-collision-constraints basic :offset-assert 64)
|
|
(collision-constraints basic :offset-assert 68)
|
|
(stick-constraints basic :offset-assert 72)
|
|
(anchor-points basic :offset-assert 76)
|
|
(constraint-strengths UNKNOWN 3 :offset-assert 80)
|
|
(num-xy-constraints int16 :offset-assert 92)
|
|
(num-diagonal-constraints int16 :offset-assert 94)
|
|
(cloth-width int32 :offset-assert 96)
|
|
(cloth-height int32 :offset-assert 100)
|
|
(strip basic :offset-assert 104)
|
|
(strip2 basic :offset-assert 108)
|
|
(strip3 basic :offset-assert 112)
|
|
(mesh basic :offset-assert 116)
|
|
(gravity-constant float :offset-assert 120)
|
|
(wind-constant float :offset-assert 124)
|
|
(flags cloth-flag :offset-assert 132)
|
|
(thickness-scalar float :offset-assert 140)
|
|
(ball-collision-radius float :offset-assert 144)
|
|
(face-normal-scalar float :offset-assert 148)
|
|
(reset-count int8 :offset-assert 152)
|
|
(num-iterations int8 :offset-assert 153)
|
|
(secret-disable uint64 :offset-assert 156)
|
|
(params cloth-params :offset-assert 164)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #xac
|
|
:flag-assert #x26000000ac
|
|
;; field cloth-flag is likely a value type.
|
|
(:methods
|
|
(cloth-system-method-16 () none) ;; 16
|
|
(cloth-system-method-17 () none) ;; 17
|
|
(cloth-system-method-18 () none) ;; 18
|
|
(cloth-system-method-19 () none) ;; 19
|
|
(cloth-system-method-20 () none) ;; 20
|
|
(cloth-system-method-21 () none) ;; 21
|
|
(cloth-system-method-22 () none) ;; 22
|
|
(cloth-system-method-23 () none) ;; 23
|
|
(cloth-system-method-24 () none) ;; 24
|
|
(cloth-system-method-25 () none) ;; 25
|
|
(cloth-system-method-26 () none) ;; 26
|
|
(cloth-system-method-27 () none) ;; 27
|
|
(cloth-system-method-28 () none) ;; 28
|
|
(cloth-system-method-29 () none) ;; 29
|
|
(cloth-system-method-30 () none) ;; 30
|
|
(cloth-system-method-31 () none) ;; 31
|
|
(cloth-system-method-32 () none) ;; 32
|
|
(cloth-system-method-33 () none) ;; 33
|
|
(cloth-system-method-34 () none) ;; 34
|
|
(cloth-system-method-35 () none) ;; 35
|
|
(cloth-system-method-36 () none) ;; 36
|
|
(cloth-system-method-37 () none) ;; 37
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cloth-on-skeleton (cloth-system)
|
|
((base-transform-index int16 :offset-assert 168)
|
|
(owner uint64 :offset-assert 172)
|
|
(last-owner-pos vector :inline :offset-assert 188)
|
|
(last-owner-mat matrix :inline :offset-assert 204)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x110
|
|
:flag-assert #x2600000110
|
|
;; field cloth-flag is likely a value type.
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bombbot-path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *bombbot-path-1* object) ;; bombbot-path
|
|
;; (define-extern *bombbot-path-2* object) ;; bombbot-path
|
|
;; (define-extern *bombbot-path-3* object) ;; bombbot-path
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; curves ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype float-pair (structure)
|
|
((first float :offset-assert 0)
|
|
(second float :offset-assert 4)
|
|
(x float :offset-assert 0)
|
|
(y float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype float-pair-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype curve2d (basic)
|
|
()
|
|
:method-count-assert 10
|
|
:size-assert #x4
|
|
:flag-assert #xa00000004
|
|
(:methods
|
|
(curve2d-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype curve-color (basic)
|
|
()
|
|
:method-count-assert 10
|
|
:size-assert #x4
|
|
:flag-assert #xa00000004
|
|
(:methods
|
|
(curve-color-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype curve2d-piecewise (curve2d)
|
|
((pts basic :offset-assert 4)
|
|
(default-loop-behavior uint64 :offset-assert 8)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x10
|
|
:flag-assert #xc00000010
|
|
(:methods
|
|
(curve2d-piecewise-method-10 () none) ;; 10
|
|
(curve2d-piecewise-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype curve2d-fast (curve2d)
|
|
((xs vector :inline :offset-assert 16)
|
|
(ys vector :inline :offset-assert 32)
|
|
(one-over-x-deltas vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x40
|
|
:flag-assert #xa00000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype curve-color-fast (curve-color)
|
|
((xs vector :inline :offset-assert 16)
|
|
(ys UNKNOWN 4 :offset-assert 32)
|
|
(one-over-x-deltas vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x70
|
|
:flag-assert #xa00000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype color-pair (structure)
|
|
((first float :offset-assert 0)
|
|
(second rgbaf :inline :offset-assert 16)
|
|
(x float :offset-assert 0)
|
|
(y rgbaf :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype color-pair-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype curve-color-piecewise (curve-color)
|
|
((pts basic :offset-assert 4)
|
|
(default-loop-behavior uint64 :offset-assert 8)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x10
|
|
:flag-assert #xb00000010
|
|
(:methods
|
|
(curve-color-piecewise-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern rgbaf-lerp! function)
|
|
;; (define-extern evaluate-curve-fast function)
|
|
;; (define-extern evaluate-color-curve-fast function)
|
|
;; (define-extern rgba<-rgbaf function)
|
|
;; (define-extern *curve-unity* curve2d-fast)
|
|
;; (define-extern *curve-linear-up* curve2d-fast)
|
|
;; (define-extern *curve-linear-down* curve2d-fast)
|
|
;; (define-extern *curve-linear-up-hold* object)
|
|
;; (define-extern *curve-linear-up-down* curve2d-fast)
|
|
;; (define-extern *trail-color-curve-white* curve-color-fast)
|
|
;; (define-extern particle-color-curve-white* curve-color-fast)
|
|
;; (define-extern *trail-color-curve-red* curve-color-fast)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ambient ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern can-display-query? function) ;; (function process string float symbol)
|
|
;; (define-extern talker-surpress! function) ;; (function none)
|
|
;; (define-extern talker-displayed? function) ;; (function symbol)
|
|
;; (define-extern kill-current-talker function) ;; (function symbol pair symbol none)
|
|
;; (define-extern string->talker-speech function) ;; (function string talker-speech-class)
|
|
;; (define-extern talker-spawn-func function) ;; (function talker-speech-class process-tree vector region sound-id)
|
|
;; (define-extern talker-init function) ;; (function talker-speech-class vector region none :behavior talker)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; waswide-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wascity-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascitya-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascityb-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
(turret-value float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-wascity function)
|
|
;; (define-extern update-mood-wascitya function)
|
|
;; (define-extern update-mood-wascityb function)
|
|
;; (define-extern set-wascityb-turret-flash! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ash-task ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fma-sphere ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fma-sphere-params (structure)
|
|
((mode uint32 :offset-assert 0)
|
|
(proc basic :offset-assert 4)
|
|
(track-joint int32 :offset-assert 8)
|
|
(duration uint64 :offset-assert 16)
|
|
(sphere sphere :offset-assert 24)
|
|
(danger traffic-danger-info :offset-assert 28)
|
|
(nav-mesh-id uint32 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fma-sphere (process-drawable)
|
|
((first-time? symbol :offset-assert 200) ;; guessed by decompiler
|
|
(mode fma-sphere-mode :offset-assert 204) ;; guessed by decompiler
|
|
(track-handle uint64 :offset-assert 208) ;; handle
|
|
(track-joint int32 :offset-assert 216)
|
|
(attack-id uint32 :offset-assert 220)
|
|
(duration uint64 :offset-assert 224) ;; time-frame
|
|
(sphere sphere :inline :offset-assert 240)
|
|
(danger traffic-danger-info :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x136
|
|
:flag-assert #x1500c00136
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern fma-sphere-init-by-other function) ;; (function fma-sphere-mode process-drawable int time-frame vector vector none :behavior fma-sphere)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prim-beam-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype prim-beam-settings (structure)
|
|
((width float :offset-assert 0)
|
|
(color uint32 :offset-assert 4)
|
|
(alpha float :offset-assert 8)
|
|
(tex-id uint32 :offset-assert 12)
|
|
(num-tiles float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prim-beam-params (structure)
|
|
((appearance prim-beam-settings :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prim-beam-tracker-params (prim-beam-params)
|
|
((track-obj1 uint64 :offset-assert 8)
|
|
(track-obj2 uint64 :offset-assert 16)
|
|
(track-joint1 int32 :offset-assert 24)
|
|
(track-joint2 int32 :offset-assert 28)
|
|
(pos0 vector :offset-assert 32)
|
|
(pos1 vector :offset-assert 36)
|
|
(duration uint64 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; generic-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype target-start (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
(:states
|
|
target-startup ;; associated process guessed by decompiler, old: (state target)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype camera-start (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cam-slope (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype med-res-level (process-drawable)
|
|
((level-name basic :offset-assert 200)
|
|
(part-mode basic :offset-assert 204)
|
|
(index int32 :offset-assert 208)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xd4
|
|
:flag-assert #x15006000d4
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype launcher (process-drawable)
|
|
((spring-height meters :offset-assert 200)
|
|
(camera state :offset-assert 204) ;; guessed by decompiler
|
|
(active-distance float :offset-assert 208)
|
|
(seek-time uint64 :offset-assert 216) ;; time-frame
|
|
(dest vector :inline :offset-assert 224)
|
|
(sound-id sound-id :offset-assert 240) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xf4
|
|
:flag-assert #x17008000f4
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
active ;; 21, old: (active () _type_ :state 21)
|
|
deactivated ;; 22, old: (deactivated () _type_ :state 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; simple-prim is already defined!
|
|
|
|
#|
|
|
(deftype simple-prim-zbuf-mask (simple-prim)
|
|
()
|
|
:method-count-assert 26
|
|
:size-assert #xcc
|
|
:flag-assert #x1a005000cc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype simple-prim-particle-binding (simple-prim)
|
|
((color uint32 :offset-assert 204)
|
|
(lifetime uint64 :offset-assert 208)
|
|
(state-time uint64 :offset-assert 192)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #xe0
|
|
:flag-assert #x1c006000e0
|
|
(:methods
|
|
(simple-prim-particle-binding-method-27 () none) ;; 27
|
|
)
|
|
(:state-methods
|
|
die ;; 26
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype part-controller (process)
|
|
((actor-group uint32 :offset-assert 124)
|
|
(actor-group-count int32 :offset-assert 128)
|
|
(spawn-delay uint64 :offset-assert 132)
|
|
(current-part-index uint16 :offset-assert 140)
|
|
(state-time uint64 :offset-assert 148)
|
|
(next-reset-time uint64 :offset-assert 156)
|
|
(reset-interval-min uint64 :offset-assert 164)
|
|
(reset-interval-max uint64 :offset-assert 172)
|
|
(particle-launchers basic :offset-assert 180)
|
|
(spawn-sound uint128 :offset-assert 188)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #xd0
|
|
:flag-assert #xf005000d0
|
|
(:state-methods
|
|
active ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-controller (process)
|
|
((spawn-sound uint128 :offset-assert 128)
|
|
(sync sync-linear :inline :offset-assert 144)
|
|
(prev-val float :offset-assert 160)
|
|
(pos vector :inline :offset-assert 176)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xc0
|
|
:flag-assert #x10004000c0
|
|
(:state-methods
|
|
die ;; 15
|
|
active ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sound-on-path (process-drawable)
|
|
((spawn-sound uint128 :offset-assert 208)
|
|
(loop-sound uint32 :offset-assert 228)
|
|
(amb-sound basic :offset-assert 232)
|
|
(is-spooling? basic :offset-assert 236)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xf0
|
|
:flag-assert #x17007000f0
|
|
(:state-methods
|
|
die ;; 21
|
|
no-play ;; 22
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype level-exit (process-drawable)
|
|
((minimap connection-minimap :offset-assert 200)
|
|
(task-counter uint32 :offset-assert 204)
|
|
(ent basic :offset-assert 208)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xd4
|
|
:flag-assert #x15006000d4
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *part-tracker-params-default* object)
|
|
;; (define-extern *part-tracker-subsampler-params-default* object)
|
|
;; (define-extern entity-lookup-part-group function) ;; (function entity-actor (pointer string) symbol (pointer sparticle-launch-group))
|
|
;; (define-extern clone-anim-once function) ;; (function handle symbol string none :behavior process-drawable)
|
|
;; (define-extern clone-anim function) ;; (function handle symbol string none :behavior process-drawable)
|
|
;; (define-extern swingpole-init function) ;; (function int object :behavior swingpole)
|
|
;; (define-extern manipy-post function) ;; (function none :behavior manipy)
|
|
;; (define-extern manipy-init function) ;; (function vector entity-actor skeleton-group vector object none :behavior manipy)
|
|
;; (define-extern part-tracker-init-base function)
|
|
;; (define-extern part-tracker-subsampler-init function)
|
|
;; (define-extern part-tracker-init function) ;; (function sparticle-launch-group time-frame (function part-tracker none) (pointer process-drawable) process matrix none :behavior part-tracker)
|
|
;; (define-extern part-tracker-track-root function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern part-tracker-move-to-target function) ;; (function part-tracker vector)
|
|
;; (define-extern part-tracker-track-target function) ;; (function part-tracker vector)
|
|
;; (define-extern lightning-tracker-init function) ;; (function lightning-spec time-frame symbol process-drawable vector vector none :behavior lightning-tracker)
|
|
;; (define-extern process-grab? function) ;; (function process symbol symbol :behavior process)
|
|
;; (define-extern process-release? function) ;; (function process symbol :behavior process)
|
|
;; (define-extern camera-look-at function) ;; (function pair uint process)
|
|
;; (define-extern ja-anim-done? function) ;; (function process symbol)
|
|
;; (define-extern camera-pov-from function) ;; (function pair uint process)
|
|
;; (define-extern cam-launcher-joystick function) ;; (function vector :behavior camera-slave)
|
|
;; (define-extern cam-launcher-shortfall state) ;; (state camera-slave)
|
|
;; (define-extern cam-launcher-long-joystick function) ;; (function vector :behavior camera-slave)
|
|
;; (define-extern cam-launcher-longfall state) ;; (state camera-slave)
|
|
;; (define-extern launcher-init-by-other function) ;; (function vector float int float none :behavior launcher)
|
|
;; (define-extern touch-tracker-init function) ;; (function vector float time-frame none :behavior touch-tracker)
|
|
;; (define-extern explosion-init-by-other function) ;; (function explosion-init-params object :behavior explosion)
|
|
;; (define-extern explosion-spawn-legacy-version function)
|
|
;; (define-extern explosion-spawn function) ;; (function process-drawable type explosion-init-params none)
|
|
;; (define-extern find-closest-solid-sphere-prim function)
|
|
;; (define-extern *explosion-debug-sphere* object)
|
|
;; (define-extern process-drawable-random-point! function) ;; (function process-drawable vector vector)
|
|
;; (define-extern process-drawable-pair-random-point! function) ;; (function process-drawable process-drawable vector float vector)
|
|
;; (define-extern simple-prim-init-by-other function)
|
|
;; (define-extern birth-func-simple-prim function)
|
|
;; (define-extern external-camera-controller-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; light-trails-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype color-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-composition (structure)
|
|
((color-mode uint64 :offset-assert 0)
|
|
(color-curve basic :offset-assert 8)
|
|
(color-repeat-dist float :offset-assert 12)
|
|
(alpha-1-mode uint64 :offset-assert 16)
|
|
(alpha-2-mode uint64 :offset-assert 24)
|
|
(base-alpha float :offset-assert 32)
|
|
(alpha-curve-1 basic :offset-assert 36)
|
|
(alpha-curve-2 basic :offset-assert 40)
|
|
(alpha-repeat-dist float :offset-assert 44)
|
|
(width-mode uint64 :offset-assert 48)
|
|
(base-width float :offset-assert 56)
|
|
(width-curve basic :offset-assert 60)
|
|
(width-repeat-dist float :offset-assert 64)
|
|
(uv-mode uint64 :offset-assert 72)
|
|
(uv-repeat-dist float :offset-assert 80)
|
|
(max-age uint64 :offset-assert 88)
|
|
(tex-id uint32 :offset-assert 96)
|
|
(lie-mode uint64 :offset-assert 104)
|
|
(lie-vector vector :inline :offset-assert 112)
|
|
(zbuffer? basic :offset-assert 128)
|
|
(use-tape-mode? basic :offset-assert 132)
|
|
(blend-mode uint64 :offset-assert 136)
|
|
(frame-stagger uint8 :offset-assert 144)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x91
|
|
:flag-assert #x900000091
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-breadcrumb (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(birth-time uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype breadcrumb-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail (basic)
|
|
((crumb-array basic :offset-assert 4)
|
|
(crumb-size uint8 :offset-assert 8)
|
|
(crumb-count int16 :offset-assert 10)
|
|
(max-crumb-count int16 :offset-assert 12)
|
|
(appearance light-trail-composition :offset-assert 16)
|
|
(start-marker uint64 :offset-assert 24)
|
|
(end-marker uint64 :offset-assert 32)
|
|
(decision uint64 :offset-assert 40)
|
|
(total-distance-traveled float :offset-assert 48)
|
|
(strip basic :offset-assert 52)
|
|
(strip2 basic :offset-assert 56)
|
|
(cache-vector UNKNOWN 4 :offset-assert 64)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x80
|
|
:flag-assert #x1600000080
|
|
(:methods
|
|
(light-trail-method-9 () none) ;; 9
|
|
(light-trail-method-10 () none) ;; 10
|
|
(light-trail-method-11 () none) ;; 11
|
|
(light-trail-method-12 () none) ;; 12
|
|
(light-trail-method-13 () none) ;; 13
|
|
(light-trail-method-14 () none) ;; 14
|
|
(light-trail-method-15 () none) ;; 15
|
|
(light-trail-method-16 () none) ;; 16
|
|
(light-trail-method-17 () none) ;; 17
|
|
(light-trail-method-18 () none) ;; 18
|
|
(light-trail-method-19 () none) ;; 19
|
|
(light-trail-method-20 () none) ;; 20
|
|
(light-trail-method-21 () none) ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype weapon-trail-crumb (light-trail-breadcrumb)
|
|
((offset vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype weapon-trail (light-trail)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #x80
|
|
:flag-assert #x1800000080
|
|
(:methods
|
|
(weapon-trail-method-22 () none) ;; 22
|
|
(weapon-trail-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tread-trail-crumb (light-trail-breadcrumb)
|
|
((normal vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tread-trail (light-trail)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #x80
|
|
:flag-assert #x1800000080
|
|
(:methods
|
|
(tread-trail-method-22 () none) ;; 22
|
|
(tread-trail-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-tracker-spawn-params (structure)
|
|
((appearance light-trail-composition :offset-assert 0)
|
|
(max-num-crumbs int32 :offset-assert 4)
|
|
(tracked-obj uint64 :offset-assert 8)
|
|
(track-immediately? basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype weapon-trail-tracker-spawn-params (light-trail-tracker-spawn-params)
|
|
((joint0 int16 :offset-assert 20)
|
|
(joint1 int16 :offset-assert 22)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-tracker (process)
|
|
((trail basic :offset-assert 128)
|
|
(tracked-object uint64 :offset-assert 136)
|
|
(offscreen? basic :offset-assert 144)
|
|
(offscreen-start-time uint64 :offset-assert 152)
|
|
(next-line-check-time uint64 :offset-assert 160)
|
|
(last-add-frame-val uint32 :offset-assert 168)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xac
|
|
:flag-assert #x15003000ac
|
|
(:methods
|
|
(light-trail-tracker-method-14 () none) ;; 14
|
|
(light-trail-tracker-method-15 () none) ;; 15
|
|
(light-trail-tracker-method-16 () none) ;; 16
|
|
(light-trail-tracker-method-17 () none) ;; 17
|
|
(light-trail-tracker-method-18 () none) ;; 18
|
|
(light-trail-tracker-method-19 () none) ;; 19
|
|
(light-trail-tracker-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype weapon-trail-tracker (light-trail-tracker)
|
|
((joint0 int16 :offset-assert 172)
|
|
(joint1 int16 :offset-assert 174)
|
|
(state-time uint64 :offset-assert 176)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xb8
|
|
:flag-assert #x16004000b8
|
|
(:methods
|
|
(weapon-trail-tracker-method-21 () none) ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tread-trail-tracker (light-trail-tracker)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xac
|
|
:flag-assert #x15003000ac
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-tracker-water (light-trail-tracker)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xac
|
|
:flag-assert #x15003000ac
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-tracker-projectile (light-trail-tracker)
|
|
((state-time uint64 :offset-assert 176)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xb8
|
|
:flag-assert #x16004000b8
|
|
(:methods
|
|
(light-trail-tracker-projectile-method-21 () none) ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern light-trail-tracker-init-by-other function)
|
|
;; (define-extern weapon-trail-tracker-init-by-other function)
|
|
;; (define-extern tread-trail-tracker-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; secrets-menu ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *menu-secrets-array* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collectables ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collectable (process-drawable)
|
|
((pickup-type int32 :offset-assert 196) ;; pickup-type
|
|
(pickup-amount float :offset-assert 200)
|
|
(notify uint64 :offset-assert 204) ;; handle
|
|
(old-base vector :inline :offset-assert 220)
|
|
(base vector :inline :offset-assert 236)
|
|
(extra-trans vector :inline :offset-assert 252)
|
|
(jump-pos vector :inline :offset-assert 268)
|
|
(flags collectable-flag :offset-assert 284)
|
|
(birth-time uint64 :offset-assert 292) ;; seconds
|
|
(collect-timeout uint64 :offset-assert 300) ;; seconds
|
|
(fadeout-timeout uint64 :offset-assert 308) ;; seconds
|
|
(bob-offset uint64 :offset-assert 316) ;; seconds
|
|
(bob-amount float :offset-assert 324)
|
|
(pickup-handle uint64 :offset-assert 332) ;; handle
|
|
(actor-pause symbol :offset-assert 340) ;; guessed by decompiler
|
|
(collect-effect basic :offset-assert 344)
|
|
(collect-effect2 basic :offset-assert 348)
|
|
(target uint64 :offset-assert 356) ;; handle
|
|
(suck-time uint64 :offset-assert 364) ;; seconds
|
|
(suck-y-offset float :offset-assert 372)
|
|
(speed vector :inline :offset-assert 380)
|
|
(movie-pos-index int32 :offset-assert 396)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x194
|
|
:flag-assert #x2401200194
|
|
(:methods
|
|
(collectable-method-29 () none) ;; 29 ;; (init-common (_type_ entity-actor pickup-type float) none 29)
|
|
(collectable-method-30 () none) ;; 30 ;; (initialize-effects (_type_ pickup-type) none 30)
|
|
(collectable-method-31 () none) ;; 31 ;; (go-to-initial-state (_type_) none 31)
|
|
(collectable-method-32 () none) ;; 32 ;; (initialize-options (_type_ int float fact-info) collectable 32)
|
|
(collectable-method-33 () none) ;; 33 ;; (initialize-allocations (_type_) none 33)
|
|
(collectable-method-34 () none) ;; 34 ;; (common-post (_type_) none 34)
|
|
(collectable-method-35 () none) ;; 35 ;; (do-pickup (_type_ handle) none 35)
|
|
)
|
|
(:state-methods
|
|
notice-blue ;; 28, old: (notice-blue (handle) _type_ :state 28)
|
|
blocked ;; 20, old: (blocked () _type_ :state 20)
|
|
jump ;; 24, old: (jump () _type_ :state 24)
|
|
deploy ;; 22, old: (deploy () _type_ :state 22)
|
|
suck ;; 23, old: (suck (handle) _type_ :state 23)
|
|
wait ;; 21, old: (wait () _type_ :state 21)
|
|
fade ;; 25, old: (fade () _type_ :state 25)
|
|
pickup ;; 26, old: (pickup (symbol handle) _type_ :state 26)
|
|
die ;; 27, old: (die () _type_ :state 27)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eco (collectable)
|
|
((respawn-delay uint64 :offset-assert 408)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x1a0
|
|
:flag-assert #x24012001a0
|
|
(:state-methods
|
|
die ;; 27
|
|
pickup ;; 26
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eco-yellow (eco)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x1a0
|
|
:flag-assert #x24012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eco-red (eco)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x1a0
|
|
:flag-assert #x24012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eco-blue (eco)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x1a0
|
|
:flag-assert #x24012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eco-green (eco)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x1a0
|
|
:flag-assert #x24012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype health (collectable)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x194
|
|
:flag-assert #x2401200194
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eco-pill (collectable)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x194
|
|
:flag-assert #x2401200194
|
|
(:state-methods
|
|
wait ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype money (collectable)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x194
|
|
:flag-assert #x2401200194
|
|
(:state-methods
|
|
notice-blue ;; 28
|
|
pickup ;; 26
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gem (money)
|
|
((roty-speed deg :offset-assert 404) ;; degrees
|
|
(bounce-time uint64 :offset-assert 408) ;; seconds
|
|
(gem-pool uint8 :offset-assert 416)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x1a1
|
|
:flag-assert #x24013001a1
|
|
(:state-methods
|
|
suck ;; 23
|
|
deploy ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype skill (money)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x194
|
|
:flag-assert #x2401200194
|
|
(:state-methods
|
|
wait ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fuel-cell (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype trick-point (collectable)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x194
|
|
:flag-assert #x2401200194
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype skate-point (trick-point)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x194
|
|
:flag-assert #x2401200194
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ammo-collectable (collectable)
|
|
((ammo-effect basic :offset-assert 404)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x198
|
|
:flag-assert #x2401200198
|
|
(:state-methods
|
|
die ;; 27
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ammo (ammo-collectable)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x198
|
|
:flag-assert #x2401200198
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shield (ammo-collectable)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x198
|
|
:flag-assert #x2401200198
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype upgrade-collectable (ammo-collectable)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x198
|
|
:flag-assert #x2401200198
|
|
)
|
|
|#
|
|
|
|
;; (define-extern initialize-eco-by-other function) ;; (function vector vector fact-info none :behavior eco)
|
|
;; (define-extern add-blue-shake function) ;; (function vector vector vector vector)
|
|
;; (define-extern check-blue-suck function) ;; (function process-drawable symbol :behavior eco)
|
|
;; (define-extern add-blue-motion function) ;; (function symbol symbol symbol symbol symbol :behavior eco)
|
|
;; (define-extern collectable-standard-event-handler function) ;; (function process int symbol event-message-block object :behavior collectable)
|
|
;; (define-extern money-init-by-other function) ;; (function vector vector fact-info entity-actor none :behavior money)
|
|
;; (define-extern money-init-by-other-no-bob function) ;; (function vector vector fact-info float entity-actor none :behavior money)
|
|
;; (define-extern *collectable-dummy-shadow-control* shadow-control) ;; shadow-control
|
|
;; (define-extern initialize-ammo-by-other function) ;; (function vector vector fact-info none :behavior ammo)
|
|
;; (define-extern initialize-upgrade-by-other function) ;; (function vector vector fact-info entity-actor none :behavior upgrade-collectable)
|
|
;; (define-extern verify-pickup-type function)
|
|
;; (define-extern birth-pickup-at-point function) ;; (function vector pickup-type float symbol process-tree fact-info (pointer process) :behavior process)
|
|
;; (define-extern pickup-dark-set! function)
|
|
;; (define-extern pickup-light-set! function)
|
|
;; (define-extern pickup-ammo-set! function)
|
|
;; (define-extern gun-pickup-type->game-feature function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hfrag-vu1-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hfrag-vu1-poly4-packet (structure)
|
|
((height-tag dma-packet :inline :offset-assert 0)
|
|
(base vector :inline :offset-assert 16)
|
|
(heights UNKNOWN 4 :offset-assert 32)
|
|
(color-tag dma-packet :inline :offset-assert 48)
|
|
(colors UNKNOWN 4 :offset-assert 64)
|
|
(next dma-packet :inline :offset-assert 80)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vu1-poly9-packet (structure)
|
|
((height-tag dma-packet :inline :offset-assert 0)
|
|
(base vector3 :inline :offset-assert 16)
|
|
(heights UNKNOWN 9 :offset-assert 28)
|
|
(color-tag dma-packet :inline :offset-assert 64)
|
|
(colors UNKNOWN 12 :offset-assert 80)
|
|
(next dma-packet :inline :offset-assert 128)
|
|
(jump-index int32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vu1-poly25-packet (structure)
|
|
((height-tag dma-packet :inline :offset-assert 0)
|
|
(base vector3 :inline :offset-assert 16)
|
|
(heights UNKNOWN 25 :offset-assert 28)
|
|
(color-tag dma-packet :inline :offset-assert 128)
|
|
(colors UNKNOWN 28 :offset-assert 144)
|
|
(next dma-packet :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x110
|
|
:flag-assert #x900000110
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vu1-vertex (structure)
|
|
((tex vector :inline :offset-assert 0)
|
|
(clr vector :inline :offset-assert 16)
|
|
(pos vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vu1-poly4 (structure)
|
|
((giftag vector :inline :offset-assert 0)
|
|
(verts UNKNOWN 4 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xd0
|
|
:flag-assert #x9000000d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vu1-poly9 (structure)
|
|
((giftag0 vector :inline :offset-assert 0)
|
|
(verts0 UNKNOWN 6 :offset-assert 16)
|
|
(giftag1 vector :inline :offset-assert 304)
|
|
(verts1 UNKNOWN 6 :offset-assert 320)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x260
|
|
:flag-assert #x900000260
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vu1-poly25 (structure)
|
|
((giftag0 vector :inline :offset-assert 0)
|
|
(verts0 UNKNOWN 10 :offset-assert 16)
|
|
(giftag1 vector :inline :offset-assert 496)
|
|
(verts1 UNKNOWN 10 :offset-assert 512)
|
|
(giftag2 vector :inline :offset-assert 992)
|
|
(verts2 UNKNOWN 10 :offset-assert 1008)
|
|
(giftag3 vector :inline :offset-assert 1488)
|
|
(verts3 UNKNOWN 10 :offset-assert 1504)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x7c0
|
|
:flag-assert #x9000007c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vu1-constants-base (structure)
|
|
((far-verts UNKNOWN 25 :offset-assert 0)
|
|
(mid-verts9 UNKNOWN 9 :offset-assert 400)
|
|
(mid-verts25 UNKNOWN 25 :offset-assert 544)
|
|
(near-verts4 UNKNOWN 4 :offset-assert 944)
|
|
(near-verts9 UNKNOWN 9 :offset-assert 1008)
|
|
(sts UNKNOWN 9 :offset-assert 1152)
|
|
(data UNKNOWN 81 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x510
|
|
:flag-assert #x900000510
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hfrag-vu1-constants (structure)
|
|
((base hfrag-vu1-constants-base :inline :offset-assert 0)
|
|
(far-verts UNKNOWN 25 :offset-assert 0)
|
|
(mid-verts9 UNKNOWN 9 :offset-assert 400)
|
|
(mid-verts25 UNKNOWN 25 :offset-assert 544)
|
|
(near-verts4 UNKNOWN 4 :offset-assert 944)
|
|
(near-verts9 UNKNOWN 9 :offset-assert 1008)
|
|
(sts UNKNOWN 9 :offset-assert 1152)
|
|
(drw-strip4 qword :inline :offset-assert 1296)
|
|
(drw-strip9-0 qword :inline :offset-assert 1312)
|
|
(drw-strip9-1 qword :inline :offset-assert 1328)
|
|
(drw-strip25-0 qword :inline :offset-assert 1344)
|
|
(drw-strip25-1 qword :inline :offset-assert 1360)
|
|
(matrix matrix :inline :offset-assert 1376)
|
|
(hvdf-offset vector :inline :offset-assert 1440)
|
|
(hmge-scale vector :inline :offset-assert 1456)
|
|
(fog vector :inline :offset-assert 1472)
|
|
(stores qword :inline :offset-assert 1488)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5e0
|
|
:flag-assert #x9000005e0
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; citizen ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype iter-seg (structure)
|
|
((self citizen :offset-assert 0) ;; guessed by decompiler
|
|
(score float :offset-assert 4)
|
|
(seg nav-segment :offset-assert 8)
|
|
(cp-plane plane :inline :offset-assert 16)
|
|
(desired-dir vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *citizen-debug* object) ;; symbol
|
|
;; (define-extern citizen-init-by-other function) ;; (function traffic-object-spawn-params none :behavior citizen)
|
|
;; (define-extern citizen-travel-anim function) ;; (function int int symbol :behavior citizen)
|
|
;; (define-extern iter-seg-clear-path function) ;; (function iter-seg nav-segment symbol)
|
|
;; (define-extern iter-seg-new-dir function) ;; (function iter-seg nav-segment none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vehicle-controller (structure)
|
|
((flags vehicle-controller-flag :offset-assert 0)
|
|
(traffic traffic-engine :offset-assert 4) ;; guessed by decompiler
|
|
(branch nav-branch :offset-assert 8)
|
|
(target-speed-offset meters :offset-assert 12)
|
|
(target-speed meters :offset-assert 16)
|
|
(choose-branch-callback (function vehicle-controller vehicle nav-branch) :offset-assert 20) ;; guessed by decompiler
|
|
(turn-accel meters :offset-assert 24)
|
|
(max-turn-speed meters :offset-assert 28)
|
|
(path-prev-point vector :inline :offset-assert 32)
|
|
(turn-enter-point vector :inline :offset-assert 48)
|
|
(turn-exit-point vector :inline :offset-assert 64)
|
|
(path-dest-point vector :inline :offset-assert 64)
|
|
(turn-enter-dir vector :inline :offset-assert 80)
|
|
(turn-exit-dir vector :inline :offset-assert 96)
|
|
(dest-circle vector :inline :offset-assert 112)
|
|
(target-point vector :inline :offset-assert 128)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x90
|
|
:flag-assert #x1600000090
|
|
(:methods
|
|
(vehicle-controller-method-9 () none) ;; 9 ;; (vehicle-controller-method-9 (_type_) none 9)
|
|
(vehicle-controller-method-10 () none) ;; 10 ;; (vehicle-controller-method-10 (_type_ traffic-tracker) none 10)
|
|
(vehicle-controller-method-11 () none) ;; 11 ;; (vehicle-controller-method-11 (_type_) none 11)
|
|
(vehicle-controller-method-12 () none) ;; 12 ;; (vehicle-controller-method-12 (_type_ rigid-body-vehicle-constants vector float int float) none 12)
|
|
(vehicle-controller-method-13 () none) ;; 13 ;; (vehicle-controller-method-13 (_type_ nav-branch vector) none 13)
|
|
(vehicle-controller-method-14 () none) ;; 14 ;; (vehicle-controller-method-14 (_type_ vehicle) nav-branch 14)
|
|
(vehicle-controller-method-15 () none) ;; 15 ;; (vehicle-controller-method-15 (_type_) nav-branch 15)
|
|
(vehicle-controller-method-16 () none) ;; 16 ;; (vehicle-controller-method-16 (_type_ vector vector) none 16)
|
|
(vehicle-controller-method-17 () none) ;; 17 ;; (draw-debug-info (_type_) none 17)
|
|
(vehicle-controller-method-18 () none) ;; 18 ;; (vehicle-controller-method-18 (_type_ vector vector vehicle float) none 18)
|
|
(vehicle-controller-method-19 () none) ;; 19 ;; (vehicle-controller-method-19 (_type_ vector object vector vector) none 19)
|
|
(vehicle-controller-method-20 () none) ;; 20 ;; (vehicle-controller-method-20 (_type_ object float) none 20)
|
|
(vehicle-controller-method-21 () none) ;; 21 ;; (vehicle-controller-method-21 (_type_) none 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *vehicle-control-debug-obj* object) ;; object
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lightning-new-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype lightning-appearance (structure)
|
|
((base-alpha float :offset-assert 0)
|
|
(width-range-start float :offset-assert 4)
|
|
(width-range-end float :offset-assert 8)
|
|
(tex-id uint32 :offset-assert 12)
|
|
(blend-mode uint64 :offset-assert 16)
|
|
(fade-time uint64 :offset-assert 24)
|
|
(regenerate-time-start uint64 :offset-assert 32)
|
|
(regenerate-time-end uint64 :offset-assert 40)
|
|
(alpha-1-curve basic :offset-assert 48)
|
|
(alpha-1-mode uint64 :offset-assert 56)
|
|
(alpha-1-repeat-dist float :offset-assert 64)
|
|
(alpha-2-curve basic :offset-assert 68)
|
|
(alpha-2-mode uint64 :offset-assert 72)
|
|
(alpha-2-repeat-dist float :offset-assert 80)
|
|
(width-curve basic :offset-assert 84)
|
|
(width-mode uint64 :offset-assert 88)
|
|
(width-repeat-dist float :offset-assert 96)
|
|
(uv-repeat-dist float :offset-assert 100)
|
|
(uv-shift? basic :offset-assert 104)
|
|
(uv-shift-speed uint64 :offset-assert 112)
|
|
(fade-time uint64 :offset-assert 24)
|
|
(use-sprite-bucket? basic :offset-assert 128)
|
|
(use-accurate-interp? basic :offset-assert 132)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x88
|
|
:flag-assert #x900000088
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-span-internal (structure)
|
|
((index int16 :offset-assert 0)
|
|
(span-flags uint8 :offset-assert 2)
|
|
(num-inner-points int8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-span (structure)
|
|
((random-offset-size-start float :offset-assert 0)
|
|
(inner-random-offset-size float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-spans-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-spans-internal-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tex-u-holder (structure)
|
|
((uu float :offset-assert 0)
|
|
(last-dist float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-bolt (basic)
|
|
((current-points basic :offset-assert 4)
|
|
(desired-points basic :offset-assert 8)
|
|
(span-pts-start basic :offset-assert 12)
|
|
(spans basic :offset-assert 16)
|
|
(spans-internal basic :offset-assert 20)
|
|
(strip1 basic :offset-assert 24)
|
|
(strip2 basic :offset-assert 28)
|
|
(inner-point-travel-time uint64 :offset-assert 32)
|
|
(start-fade-time uint64 :offset-assert 40)
|
|
(new-inner-point-generate-time uint64 :offset-assert 48)
|
|
(last-generate-time uint64 :offset-assert 56)
|
|
(base-width float :offset-assert 64)
|
|
(current-uv-shift float :offset-assert 68)
|
|
(current-fade-scalar float :offset-assert 72)
|
|
(fractal-reduction float :offset-assert 76)
|
|
(appearance lightning-appearance :offset-assert 80)
|
|
(fade-mode uint64 :offset-assert 88)
|
|
(generate-mode uint64 :offset-assert 96)
|
|
(snap-inner-points? basic :offset-assert 104)
|
|
(span-data UNKNOWN 2 :offset-assert 108)
|
|
(num-active-spans int8 :offset-assert 108)
|
|
(num-spans int8 :offset-assert 109)
|
|
(base-color uint32 :offset-assert 112)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x74
|
|
:flag-assert #x1700000074
|
|
(:methods
|
|
(lightning-bolt-method-9 () none) ;; 9
|
|
(lightning-bolt-method-10 () none) ;; 10
|
|
(lightning-bolt-method-11 () none) ;; 11
|
|
(lightning-bolt-method-12 () none) ;; 12
|
|
(lightning-bolt-method-13 () none) ;; 13
|
|
(lightning-bolt-method-14 () none) ;; 14
|
|
(lightning-bolt-method-15 () none) ;; 15
|
|
(lightning-bolt-method-16 () none) ;; 16
|
|
(lightning-bolt-method-17 () none) ;; 17
|
|
(lightning-bolt-method-18 () none) ;; 18
|
|
(lightning-bolt-method-19 () none) ;; 19
|
|
(lightning-bolt-method-20 () none) ;; 20
|
|
(lightning-bolt-method-21 () none) ;; 21
|
|
(lightning-bolt-method-22 () none) ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-new-tracker (process)
|
|
((bolt basic :offset-assert 128)
|
|
(lifetime uint64 :offset-assert 136)
|
|
(state-time uint64 :offset-assert 144)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x98
|
|
:flag-assert #x1000200098
|
|
(:methods
|
|
(lightning-new-tracker-method-14 () none) ;; 14
|
|
(lightning-new-tracker-method-15 () none) ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-tracker-init-params (structure)
|
|
((appearance lightning-appearance :offset-assert 0)
|
|
(start-pt vector :inline :offset-assert 16)
|
|
(end-pt vector :inline :offset-assert 32)
|
|
(lifetime uint64 :offset-assert 48)
|
|
(num-inner-points int8 :offset-assert 56)
|
|
(inner-random-offset-size float :offset-assert 60)
|
|
(random-offset-size-start float :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; carry-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype carry-info (basic)
|
|
((process (pointer target) :offset-assert 4) ;; guessed by decompiler
|
|
(pickup-time uint64 :offset-assert 8) ;; time-frame
|
|
(other-value float :offset-assert 16)
|
|
(other uint64 :offset-assert 24) ;; handle
|
|
(point vector :inline :offset-assert 32)
|
|
(normal vector :inline :offset-assert 48)
|
|
(max-angle deg :offset-assert 64) ;; degrees
|
|
(max-distance meters :offset-assert 68)
|
|
(max-pull meters :offset-assert 72)
|
|
(min-pull meters :offset-assert 76)
|
|
(grab-trans-blend float :offset-assert 80)
|
|
(carry-radius meters :offset-assert 84)
|
|
(backup-radius meters :offset-assert 88)
|
|
(joint int8 :offset-assert 92)
|
|
(mode carry-mode :offset-assert 93)
|
|
(face-dir int8 :offset-assert 94)
|
|
(local-point vector :inline :offset-assert 96)
|
|
(local-normal vector :inline :offset-assert 112)
|
|
(grab-quat vector :inline :offset-assert 128) ;; quaternion :inline
|
|
(grab-trans vector :inline :offset-assert 144)
|
|
(hold-trans vector :inline :offset-assert 160)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #xb0
|
|
:flag-assert #x11000000b0
|
|
;; field carry-mode is likely a value type.
|
|
(:methods
|
|
;; (new (symbol type process-drawable int vector vector float) _type_ 0)
|
|
(carry-info-method-9 () none) ;; 9 ;; (carry-info-method-9 (_type_) none 9)
|
|
(carry-info-method-10 () none) ;; 10 ;; (distance-from-destination (_type_ carry-info) float 10)
|
|
(carry-info-method-11 () none) ;; 11 ;; (drag! (_type_ carry-info) none 11)
|
|
(carry-info-method-12 () none) ;; 12 ;; (drop-impl! (_type_ carry-info) none 12)
|
|
(carry-info-method-13 () none) ;; 13 ;; (carry-info-method-13 (_type_) symbol 13)
|
|
(carry-info-method-14 () none) ;; 14 ;; (carry! (_type_ carry-info vector vector) none 14)
|
|
(carry-info-method-15 () none) ;; 15 ;; (drop! (_type_ carry-info) none 15)
|
|
(carry-info-method-16 () none) ;; 16 ;; (translate! (_type_) symbol 16)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bouncer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bouncer (process-drawable)
|
|
((spring-height meters :offset-assert 200)
|
|
(smush float :offset-assert 204)
|
|
(mods basic :offset-assert 208)
|
|
(use-alternate-jump? basic :offset-assert 212)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xd8
|
|
:flag-assert #x1b006000d8
|
|
(:methods
|
|
(bouncer-method-23 () none) ;; 23 ;; (init-skeleton! (_type_) none 23)
|
|
(bouncer-method-24 () none) ;; 24 ;; (bouncer-method-24 (_type_) none 24)
|
|
(bouncer-method-25 () none) ;; 25
|
|
(bouncer-method-26 () none) ;; 26
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
smush ;; 22, old: (smush () _type_ :state 22)
|
|
fire ;; 21, old: (fire () _type_ :state 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lightjak-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wings (process-drawable)
|
|
((shadow-backup basic :offset-assert 208)
|
|
(ragdoll-proc uint64 :offset-assert 216)
|
|
(lock? basic :offset-assert 224)
|
|
(wing-part UNKNOWN 2 :offset-assert 228)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xec
|
|
:flag-assert #x18007000ec
|
|
(:methods
|
|
(wings-method-20 () none) ;; 20
|
|
(wings-method-21 () none) ;; 21
|
|
(wings-method-22 () none) ;; 22
|
|
(wings-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightjak-shield (process-drawable)
|
|
((fade float :offset-assert 200)
|
|
(tone uint32 :offset-assert 204)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd0
|
|
:flag-assert #x17005000d0
|
|
(:methods
|
|
(lightjak-shield-method-20 () none) ;; 20
|
|
(lightjak-shield-method-21 () none) ;; 21
|
|
(lightjak-shield-method-22 () none) ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightjak-info (basic)
|
|
((process uint32 :offset-assert 4)
|
|
(wings uint32 :offset-assert 8)
|
|
(get-off-lock basic :offset-assert 12)
|
|
(latch-out-time uint64 :offset-assert 16)
|
|
(start-time uint64 :offset-assert 24)
|
|
(attack-id uint32 :offset-assert 32)
|
|
(lightjak-before-powerjak basic :offset-assert 36)
|
|
(attack-time uint64 :offset-assert 40)
|
|
(attack-count uint64 :offset-assert 48)
|
|
(stage uint32 :offset-assert 56)
|
|
(want-stage uint32 :offset-assert 60)
|
|
(get-on-latch uint32 :offset-assert 64)
|
|
(tone uint32 :offset-assert 68)
|
|
(on-off uint32 :offset-assert 72)
|
|
(mode-sound-bank connection :offset-assert 76)
|
|
(swoop-count int32 :offset-assert 80)
|
|
(freeze-control uint64 :offset-assert 88)
|
|
(freeze-screen uint64 :offset-assert 96)
|
|
(freeze-sound uint32 :offset-assert 104)
|
|
(shield uint32 :offset-assert 108)
|
|
(shield-start-time uint64 :offset-assert 112)
|
|
(shield-count-time uint64 :offset-assert 120)
|
|
(regen-start-time uint64 :offset-assert 128)
|
|
(regen-time uint64 :offset-assert 136)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gun (process-drawable)
|
|
((control control-info :offset-assert 128) ;; guessed by decompiler
|
|
(shadow-backup shadow-geo :offset-assert 208) ;; guessed by decompiler
|
|
(read-scale basic :offset-assert 212)
|
|
(gun-type int32 :offset-assert 216) ;; pickup-type
|
|
(barrel joint-mod 2 :offset-assert 220) ;; guessed by decompiler
|
|
(mag joint-mod 4 :offset-assert 228) ;; guessed by decompiler
|
|
(mag-scale float 4 :offset-assert 244) ;; guessed by decompiler
|
|
(extra uint64 :offset-assert 264)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x110
|
|
:flag-assert #x1800900110
|
|
(:methods
|
|
(gun-method-20 () none) ;; 20 ;; (idle () _type_ :state 20)
|
|
(gun-method-21 () none) ;; 21 ;; (use (symbol) _type_ :state 21)
|
|
(gun-method-22 () none) ;; 22 ;; (hidden () _type_ :state 22)
|
|
(gun-method-23 () none) ;; 23 ;; (die () _type_ :state 23)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-info (basic)
|
|
((process (pointer target) :offset-assert 4) ;; guessed by decompiler
|
|
(gun (pointer gun) :offset-assert 8) ;; guessed by decompiler
|
|
(gun-pos transformq :inline :offset-assert 16)
|
|
(gun-trans vector :inline :offset-assert 16)
|
|
(gun-quat vector :inline :offset-assert 32) ;; quaternion :inline
|
|
(gun-scale vector :inline :offset-assert 48)
|
|
(active? symbol :offset-assert 72) ;; guessed by decompiler
|
|
(latch? symbol :offset-assert 76) ;; guessed by decompiler
|
|
(put-away? symbol :offset-assert 80) ;; guessed by decompiler
|
|
(surpress-time uint64 :offset-assert 88) ;; time-frame
|
|
(fire-time uint64 :offset-assert 96) ;; time-frame
|
|
(gun-delay-fire float :offset-assert 104)
|
|
(gun-time uint64 :offset-assert 112) ;; time-frame
|
|
(gun-get-on-time uint64 :offset-assert 120) ;; time-frame
|
|
(active-time uint64 :offset-assert 128) ;; time-frame
|
|
(fire-delay uint32 :offset-assert 136)
|
|
(gun-control uint32 :offset-assert 140)
|
|
(gun-target uint32 :offset-assert 144)
|
|
(gun-daxter float :offset-assert 148)
|
|
(gun-select-time UNKNOWN 4 :offset-assert 152)
|
|
(gun-roty-rel deg :offset-assert 184) ;; degrees
|
|
(gun-roty deg :offset-assert 188) ;; degrees
|
|
(gun-roty-targ deg :offset-assert 192) ;; degrees
|
|
(hips joint-mod :offset-assert 196) ;; guessed by decompiler
|
|
(upper-body joint-mod :offset-assert 200) ;; guessed by decompiler
|
|
(chest joint-mod :offset-assert 204) ;; guessed by decompiler
|
|
(strip basic :offset-assert 208)
|
|
(uv-slide float :offset-assert 212)
|
|
(fire-dir-rot deg :offset-assert 216) ;; degrees
|
|
(fire-dir vector :inline :offset-assert 224)
|
|
(fire-point vector :inline :offset-assert 256)
|
|
(fire-dir-backup vector :inline :offset-assert 272)
|
|
(fire-dir-out vector :inline :offset-assert 288)
|
|
(fire-pending int32 :offset-assert 304)
|
|
(fire-pending-time uint64 :offset-assert 312) ;; time-frame
|
|
(fire-start-time uint64 :offset-assert 320) ;; time-frame
|
|
(fire-charge float :offset-assert 328)
|
|
(fire-spin deg :offset-assert 332) ;; degrees
|
|
(fire-spinv deg :offset-assert 336) ;; degrees
|
|
(fire-chamber int32 :offset-assert 340)
|
|
(fire-range meters :offset-assert 344)
|
|
(laser-active? symbol :offset-assert 348) ;; guessed by decompiler
|
|
(laser-point vector :inline :offset-assert 352)
|
|
(laser-dir vector :inline :offset-assert 368)
|
|
(laser-hit-point vector :inline :offset-assert 400)
|
|
(track? uint16 :offset-assert 416) ;; gun-track-flags
|
|
(track-tilt deg :offset-assert 420) ;; degrees
|
|
(track-turn deg :offset-assert 424) ;; degrees
|
|
(track-find-range meters :offset-assert 428)
|
|
(track-turnv-range meters :offset-assert 432)
|
|
(track-tilt-range meters :offset-assert 436)
|
|
(track-turn-range meters :offset-assert 440)
|
|
(track-tilt-max deg :offset-assert 444) ;; degrees
|
|
(track-turn-max deg :offset-assert 448) ;; degrees
|
|
(track-angle-mult float :offset-assert 452)
|
|
(track-beam-size float :offset-assert 456)
|
|
(track-auto-fire symbol :offset-assert 460) ;; guessed by decompiler
|
|
(track-require uint32 :offset-assert 464)
|
|
(track-target-hold-time uint64 :offset-assert 472) ;; time-frame
|
|
(track-start-time uint64 :offset-assert 480) ;; time-frame
|
|
(track-press-start-time uint64 :offset-assert 488) ;; time-frame
|
|
(track-target focus 2 :offset-assert 496) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(track-trans vector :inline :offset-assert 528)
|
|
(track-dir vector :inline :offset-assert 544)
|
|
(turn-fast-hold-time uint64 :offset-assert 560) ;; time-frame
|
|
(blue-whine-sound-id sound-id :offset-assert 568) ;; guessed by decompiler
|
|
(blue-whine-volume float :offset-assert 572)
|
|
(mode-sound-bank connection :offset-assert 576)
|
|
(top-anim-twist vector :inline :offset-assert 592)
|
|
(top-anim-twist-targ vector :inline :offset-assert 608)
|
|
(top-anim-look-at vector :inline :offset-assert 624)
|
|
(top-anim-twist-reset uint64 :offset-assert 640)
|
|
(top-anim-gun-height meters :offset-assert 648)
|
|
(top-anim-blue-cycle float :offset-assert 652)
|
|
(top-anim-low-high float :offset-assert 656)
|
|
(top-anim-extra-twistv deg :offset-assert 660) ;; degrees
|
|
(top-anim-tilt-up deg :offset-assert 664) ;; degrees
|
|
(attack-combo combo-tracker :inline :offset-assert 672)
|
|
(combo-window-start uint64 :offset-assert 720) ;; time-frame
|
|
(combo-window-state symbol :offset-assert 728) ;; guessed by decompiler
|
|
(combo-fire-delay uint32 :offset-assert 732)
|
|
(charge-ammo float :offset-assert 736)
|
|
(charge-start-time uint64 :offset-assert 744) ;; time-frame
|
|
(charge-inc-time uint64 :offset-assert 752) ;; time-frame
|
|
(charge-active? uint64 :offset-assert 760) ;; handle
|
|
(part basic :offset-assert 768)
|
|
(ammo-required float :offset-assert 772)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x308
|
|
:flag-assert #xa00000308
|
|
(:methods
|
|
(gun-info-method-9 () none) ;; 9 ;; (gun-info-method-9 (_type_) (inline-array vector) 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype beam-info (structure)
|
|
((y-scale float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern using-gun? function) ;; (function target symbol)
|
|
;; (define-extern enabled-gun? function) ;; (function target symbol)
|
|
;; (define-extern gun->ammo function) ;; (function pickup-type int)
|
|
;; (define-extern gun->eco function)
|
|
;; (define-extern *gun-shadow-control* shadow-control) ;; shadow-control
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precura-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype precur-switch (process-drawable)
|
|
((alt-actor basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xcc
|
|
:flag-assert #x18005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
going-down ;; 21
|
|
going-up ;; 22
|
|
idle-down ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-jump-plate (process-drawable)
|
|
((start-quat quaternion :inline :offset-assert 208)
|
|
(turn-start uint64 :offset-assert 224)
|
|
(angle float :offset-assert 232)
|
|
(first? basic :offset-assert 236)
|
|
(idx uint8 :offset-assert 240)
|
|
(sound-id uint32 :offset-assert 244)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xf8
|
|
:flag-assert #x16008000f8
|
|
(:state-methods
|
|
idle ;; 20
|
|
turn ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-generator (process-drawable)
|
|
((attack-id uint32 :offset-assert 200)
|
|
(shove-id uint32 :offset-assert 204)
|
|
(sound-id uint32 :offset-assert 208)
|
|
(next-lightning-time uint32 :offset-assert 212)
|
|
(shock-distance float :offset-assert 216)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xdc
|
|
:flag-assert #x17006000dc
|
|
(:methods
|
|
(precur-generator-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-generator-a (precur-generator)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xdc
|
|
:flag-assert #x17006000dc
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-generator-b (precur-generator)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xdc
|
|
:flag-assert #x17006000dc
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-generator-c (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
(next-lightning-time uint32 :offset-assert 204)
|
|
(sound-id uint32 :offset-assert 208)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd8
|
|
:flag-assert #x16006000d8
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-generator-d-gem (process-drawable)
|
|
((ang-vel float :offset-assert 200)
|
|
(offset-vec vector :inline :offset-assert 208)
|
|
(init-pos vector :inline :offset-assert 224)
|
|
(sound-id uint32 :offset-assert 240)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xf4
|
|
:flag-assert #x18008000f4
|
|
(:state-methods
|
|
idle ;; 20
|
|
orbit-gen ;; 21
|
|
smoking ;; 22
|
|
explode ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-generator-d (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
(next-lightning-time uint32 :offset-assert 204)
|
|
(proc-handle UNKNOWN 3 :offset-assert 212)
|
|
(animation-speed float :offset-assert 236)
|
|
(sound-id uint32 :offset-assert 240)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xf8
|
|
:flag-assert #x18008000f8
|
|
(:methods
|
|
(precur-generator-d-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
explosions ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-platform-round (process-drawable)
|
|
((start-quat quaternion :inline :offset-assert 208)
|
|
(start-height float :offset-assert 224)
|
|
(sound-id uint32 :offset-assert 228)
|
|
(start-dip-time float :offset-assert 232)
|
|
(last-ridden-time float :offset-assert 236)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xf0
|
|
:flag-assert #x19007000f0
|
|
(:methods
|
|
(precur-platform-round-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
hidden-state ;; 21
|
|
fade-in ;; 23
|
|
rotate-plat ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-door-d (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precur-door-c (process-drawable)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
(:methods
|
|
(precur-door-c-method-22 () none) ;; 22
|
|
(precur-door-c-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
explode ;; 21
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-precur-tour (task-manager)
|
|
((hint-type uint8 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf1
|
|
:flag-assert #x20008000f1
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precura-door-a (process-drawable)
|
|
((open-test basic :offset-assert 200)
|
|
(open-started uint64 :offset-assert 208)
|
|
(do-camera? basic :offset-assert 216)
|
|
(open-frame float :offset-assert 220)
|
|
(precur-tour? basic :offset-assert 224)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xe4
|
|
:flag-assert #x17007000e4
|
|
;; field open-test uses ~A with a signed load.
|
|
(:methods
|
|
(precura-door-a-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
close ;; 21
|
|
open ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spawn-mech-shock-effect function)
|
|
;; (define-extern *precur-generator-a-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *precur-generator-b-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *precur-generator-c-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern precur-generator-d-gem-init-by-other function)
|
|
;; (define-extern *precur-generator-d-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern rotate-platform-behavior function)
|
|
;; (define-extern *precur-door-d-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern precur-door-d-init-by-other function)
|
|
;; (define-extern *precur-door-c-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern precur-door-c-handler function)
|
|
;; (define-extern hint-type->string function)
|
|
;; (define-extern precura-do-blur-if-more-than-dist-away function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; darkjak-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype darkjak-info (basic)
|
|
((process (pointer target) :offset-assert 4) ;; guessed by decompiler
|
|
(latch-out-time uint64 :offset-assert 8)
|
|
(attack-id uint32 :offset-assert 16)
|
|
(start-time uint64 :offset-assert 24) ;; time-frame
|
|
(attack-time uint64 :offset-assert 32) ;; time-frame
|
|
(attack-count uint64 :offset-assert 40)
|
|
(lightning-count int32 :offset-assert 48)
|
|
(charge-effect uint64 :offset-assert 56)
|
|
(stage darkjak-stage :offset-assert 64) ;; guessed by decompiler
|
|
(want-stage darkjak-stage :offset-assert 68) ;; guessed by decompiler
|
|
(clock-pos float :offset-assert 72)
|
|
(clock-vel float :offset-assert 76)
|
|
(clock-on symbol :offset-assert 80) ;; guessed by decompiler
|
|
(hud handle 1 :offset-assert 88) ;; guessed by decompiler
|
|
(tone sound-id :offset-assert 96) ;; guessed by decompiler
|
|
(bomb uint32 :offset-assert 100)
|
|
(mode-sound-bank connection :offset-assert 104)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x6c
|
|
:flag-assert #xa0000006c
|
|
(:methods
|
|
(darkjak-info-method-9 () none) ;; 9 ;; (update-clock! (_type_ int) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sidekick ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sidekick-remap* object) ;; pair
|
|
;; (define-extern cspace<-cspace+transformq! function) ;; (function cspace cspace transformq matrix)
|
|
;; (define-extern target-sidekick-setup function) ;; (function symbol none :behavior target)
|
|
;; (define-extern init-sidekick function) ;; (function none :behavior sidekick)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-birth-func-brightness-part-droppings-for function)
|
|
;; (define-extern birth-func-copy-target-y-rot function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern birth-func-ground-orient function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern birth-func-target-orient function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern birth-func-vector-orient function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern birth-func-set-alpha-from-userdata function) ;; (function int sparticle-cpuinfo sparticle-launchinfo float)
|
|
;; (define-extern part-tracker-track-target-joint function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern spt-birth-func-part-land-droppings-for function)
|
|
;; (define-extern spt-birth-func-part-droppings-for function)
|
|
;; (define-extern spt-birth-func-part-slide-droppings-for function)
|
|
;; (define-extern spt-birth-func-part-jump-droppings-for function)
|
|
;; (define-extern process-drawable-burn-effect function) ;; (function time-frame rgbaf :behavior target)
|
|
;; (define-extern lightning-probe-callback function) ;; (function lightning-tracker none)
|
|
;; (define-extern process-drawable-shock-effect-replace function)
|
|
;; (define-extern process-drawable-shock-effect function) ;; (function process-drawable lightning-spec (function lightning-tracker none) sparticle-launcher int int float object)
|
|
;; (define-extern process-drawable-shock-wall-effect function) ;; (function process-drawable lightning-spec (function lightning-tracker none) sparticle-launcher symbol)
|
|
;; (define-extern process-drawable2-shock-effect function) ;; (function process-drawable process-drawable lightning-spec (function lightning-tracker none) sparticle-launcher none)
|
|
;; (define-extern process-drawable-shock-skel-effect function) ;; (function process-drawable lightning-spec (function lightning-tracker none) sparticle-launcher float int int none)
|
|
;; (define-extern *lightning-darkjak-pill* object) ;; lightning-spec
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern sparticle-track-gun-joint function)
|
|
;; (define-extern *red-shot-colors* object) ;; (pointer rgba)
|
|
;; (define-extern *range-explo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-gun-red3-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-explo-color* curve-color-fast)
|
|
;; (define-extern *range-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-gun-red3-explosion-texture-curve-settings* object)
|
|
;; (define-extern *curve-linear-up-red* object)
|
|
;; (define-extern *red-shot-3-trail* object)
|
|
;; (define-extern *curve-yellow2-shot-alpha* object)
|
|
;; (define-extern *curve-yellow2-shot-color* curve-color-fast)
|
|
;; (define-extern *curve-linear-down-long* curve2d-fast)
|
|
;; (define-extern *yellow-shot-2-trail* object)
|
|
;; (define-extern check-shell-level1 function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern check-shell-level2 function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-dark-shot-lightning function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-track-gun-joint-3d function)
|
|
;; (define-extern sparticle-track-gun-joint-player-y function)
|
|
;; (define-extern *last-player-pos* object)
|
|
;; (define-extern birth-func-converge function)
|
|
;; (define-extern sparticle-red-2-converge function)
|
|
;; (define-extern sparticle-red-2-glow-trail-halt function)
|
|
;; (define-extern *gun-dark-3-nuke-fade-time* object)
|
|
;; (define-extern *gun-dark-3-nuke-fade-curve* object)
|
|
;; (define-extern *gun-dark-3-nuke-blur-segs* object)
|
|
;; (define-extern *gun-dark-3-nuke-blur-time* object)
|
|
;; (define-extern *gun-dark-3-nuke-blur-curve* object)
|
|
;; (define-extern *gun-dark-3-mushroom-speed* object)
|
|
;; (define-extern *gun-dark-3-mushroom-size-time* object)
|
|
;; (define-extern *gun-dark-3-nuke-mushroom-size-curve-x* object)
|
|
;; (define-extern *gun-dark-3-nuke-mushroom-size-curve-y* object)
|
|
;; (define-extern *gun-dark-3-nuke-fade-time-small* object)
|
|
;; (define-extern *gun-dark-3-nuke-fade-curve-small* object)
|
|
;; (define-extern *gun-dark-3-nuke-blur-segs-small* object)
|
|
;; (define-extern *gun-dark-3-nuke-blur-time-small* object)
|
|
;; (define-extern *gun-dark-3-nuke-blur-curve-small* object)
|
|
;; (define-extern spt-func-part-gun-dark-1-upgrade-shot-edges function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kg-grunt ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype kg-grunt-anim-info (structure)
|
|
((anim-index int32 :offset-assert 0)
|
|
(travel-speed meters :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-grunt-global-info (basic)
|
|
((prev-knocked-anim-index int32 :offset-assert 4)
|
|
(prev-yellow-hit-anim-index int32 :offset-assert 8)
|
|
(prev-blue-hit-anim-index int32 :offset-assert 12)
|
|
(patrol-anim UNKNOWN 4 :offset-assert 16)
|
|
(charge-anim UNKNOWN 3 :offset-assert 48)
|
|
(attack-anim UNKNOWN 2 :offset-assert 72)
|
|
(knocked-anim UNKNOWN 4 :offset-assert 88)
|
|
(knocked-land-anim UNKNOWN 4 :offset-assert 120)
|
|
(yellow-hit-anim UNKNOWN 4 :offset-assert 152)
|
|
(blue-hit-anim UNKNOWN 6 :offset-assert 184)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xe8
|
|
:flag-assert #x9000000e8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-grunt (nav-enemy)
|
|
((patrol-anim kg-grunt-anim-info :offset-assert 620)
|
|
(charge-anim kg-grunt-anim-info :offset-assert 624)
|
|
(attack-anim kg-grunt-anim-info :offset-assert 628)
|
|
(knocked-anim kg-grunt-anim-info :offset-assert 632)
|
|
(yellow-hit-anim kg-grunt-anim-info :offset-assert 636)
|
|
(blue-hit-anim kg-grunt-anim-info :offset-assert 640)
|
|
(intro-path basic :offset-assert 644)
|
|
(use-charge-anim-index int8 :offset-assert 652)
|
|
(knocked-anim-index int8 :offset-assert 653)
|
|
(jumping-ambush-path-pt int8 :offset-assert 654)
|
|
(kg-grunt-flags uint8 :offset-assert 655)
|
|
(state-timeout2 uint64 :offset-assert 656)
|
|
(next-warn-time uint64 :offset-assert 664)
|
|
(dest vector :inline :offset-assert 672)
|
|
(focus-pos vector :inline :offset-assert 352)
|
|
(minimap connection-minimap :offset-assert 704)
|
|
(debris-count uint32 :offset-assert 708)
|
|
(debris-mask uint32 :offset-assert 712)
|
|
)
|
|
:method-count-assert 199
|
|
:size-assert #x2cc
|
|
:flag-assert #xc7025002cc
|
|
(:methods
|
|
(kg-grunt-method-197 () none) ;; 197
|
|
(kg-grunt-method-198 () none) ;; 198
|
|
)
|
|
(:state-methods
|
|
explode ;; 196
|
|
falling-ambush ;; 191
|
|
jumping-ambush ;; 192
|
|
jumping-ambush-cont ;; 193
|
|
active ;; 34
|
|
attack ;; 190
|
|
hostile ;; 38
|
|
spin-attack ;; 195
|
|
circling ;; 157
|
|
pacing ;; 156
|
|
stop-chase ;; 158
|
|
wait-for-focus ;; 194
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *kg-grunt-debris-params* debris-static-params)
|
|
;; (define-extern *kg-grunt-debris-elbow-shoulder-params* debris-static-params)
|
|
;; (define-extern *kg-grunt-debris-array-params* array)
|
|
;; (define-extern *kg-grunt-debris-knee-hip-params* debris-static-params)
|
|
;; (define-extern *kg-grunt-global-info* kg-grunt-global-info)
|
|
;; (define-extern *fact-info-kg-grunt-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *kg-grunt-nav-enemy-info* nav-enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collectables-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern eco-fadeout function) ;; (function sparticle-system sparticle-cpuinfo none)
|
|
;; (define-extern eco-track-root-prim-fadeout function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern sparticle-3d-rotate-xz-to-camera-eco-shaft function)
|
|
;; (define-extern spt-func-part-vent-eco-dark-shaft function)
|
|
;; (define-extern spt-func-part-vent-eco-dark-touched-specs function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; krimson-wall ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype krimson-wall-break (process-drawable)
|
|
((art-name basic :offset-assert 200)
|
|
(anim basic :offset-assert 204)
|
|
(pillar UNKNOWN 2 :offset-assert 208)
|
|
(level-name basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xdc
|
|
:flag-assert #x17006000dc
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
done ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype krimson-wall (process-focusable)
|
|
((alt-actor UNKNOWN 2 :offset-assert 208)
|
|
(collision-part int32 :offset-assert 216)
|
|
(width float :offset-assert 220)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #xe0
|
|
:flag-assert #x1f006000e0
|
|
(:methods
|
|
(krimson-wall-method-30 () none) ;; 30
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern krimson-wall-break-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; find-nearest ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype search-info (structure)
|
|
((point vector :inline :offset-assert 0)
|
|
(best-point vector :inline :offset-assert 16)
|
|
(match-handle uint64 :offset-assert 32) ;; handle
|
|
(match basic :offset-assert 40)
|
|
(best float :offset-assert 44)
|
|
(radius float :offset-assert 48)
|
|
(rating search-info-flag :offset-assert 52)
|
|
(require search-info-flag :offset-assert 56)
|
|
(mask search-info-flag :offset-assert 60)
|
|
(rot-base vector :inline :offset-assert 64)
|
|
(back-point vector :inline :offset-assert 80)
|
|
(rot-range float :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x64
|
|
:flag-assert #x900000064
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *search-info* object) ;; search-info
|
|
;; (define-extern find-nearest-focusable function) ;; (function (array collide-shape) vector float search-info-flag search-info-flag vector vector float basic)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; aligner ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-sewb ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sewb-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hvehicle-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hvehicle (vehicle)
|
|
((flight-level-index int8 :offset-assert 696)
|
|
(flight-level-index-prev int8 :offset-assert 697)
|
|
(flight-level float :offset-assert 700)
|
|
(jump-time float :offset-assert 704)
|
|
(jump-thrust float :offset-assert 708)
|
|
(engine-thrust float :offset-assert 712)
|
|
(lift-thrust UNKNOWN 4 :offset-assert 716)
|
|
(roll-thrust UNKNOWN 2 :offset-assert 732)
|
|
(engine-sound-id uint32 :offset-assert 740)
|
|
(thrust-sound-id uint32 :offset-assert 744)
|
|
(roll-sound-id uint32 :offset-assert 748)
|
|
(damage-pop-sound-id uint32 :offset-assert 752)
|
|
(extra-sound-id uint32 :offset-assert 756)
|
|
(engine-sound-envelope float :offset-assert 760)
|
|
(engine-sound-factor float :offset-assert 764)
|
|
(sputter-sound-envelope float :offset-assert 768)
|
|
(transition-time uint64 :offset-assert 776)
|
|
(transition-end-time uint64 :offset-assert 784)
|
|
(controller vehicle-controller :inline :offset-assert 800)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x3b0
|
|
:flag-assert #xa2033003b0
|
|
(:methods
|
|
(hvehicle-method-152 () none) ;; 152
|
|
(hvehicle-method-153 () none) ;; 153
|
|
(hvehicle-method-154 () none) ;; 154
|
|
(hvehicle-method-155 () none) ;; 155
|
|
(hvehicle-method-156 () none) ;; 156
|
|
(hvehicle-method-157 () none) ;; 157
|
|
(hvehicle-method-158 () none) ;; 158
|
|
(hvehicle-method-159 () none) ;; 159
|
|
(hvehicle-method-160 () none) ;; 160
|
|
(hvehicle-method-161 () none) ;; 161
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; task-arrow ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-arrow (process-drawable)
|
|
((pos vector :inline :offset-assert 208)
|
|
(theta float :offset-assert 224)
|
|
(phi float :offset-assert 228)
|
|
(dist float :offset-assert 232)
|
|
(smoothed-dist float :offset-assert 236)
|
|
(max-dist float :offset-assert 240)
|
|
(flags task-arrow-flags :offset-assert 244) ;; guessed by decompiler
|
|
(map-icon uint16 :offset-assert 248)
|
|
(minimap connection-minimap :offset-assert 252)
|
|
(hud-dist uint64 :offset-assert 256) ;; handle
|
|
(base-quat quaternion :inline :offset-assert 272)
|
|
(base-scale float :offset-assert 288)
|
|
(rod-of-god-scale float :offset-assert 292)
|
|
(moving symbol :offset-assert 296) ;; guessed by decompiler
|
|
(death-pending? basic :offset-assert 300)
|
|
(alpha float :offset-assert 304)
|
|
(choir-sound basic :offset-assert 308)
|
|
(draw-back basic :offset-assert 312)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x13c
|
|
:flag-assert #x1900c0013c
|
|
(:methods
|
|
(task-arrow-method-23 () none) ;; 23 ;; (task-arrow-method-23 (_type_ vector) none 23)
|
|
(task-arrow-method-24 () none) ;; 24 ;; (draw-arrow (_type_) none 24)
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
leave ;; 22, old: (leave () _type_ :state 22)
|
|
die ;; 21, old: (die () _type_ :state 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern task-arrow-init-by-other function) ;; (function task-arrow-params task-arrow :behavior task-arrow)
|
|
;; (define-extern task-arrow-spawn function) ;; (function task-arrow-params process-tree process)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; simple-focus ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype simple-focus (process-focusable)
|
|
((first-time? symbol :offset-assert 208) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #xd4
|
|
:flag-assert #x1d006000d4
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern simple-focus-init-by-other function) ;; (function none :behavior simple-focus)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mission-squad-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cshape-reaction-projectile function) ;; (function control-info collide-query vector vector collide-status)
|
|
;; (define-extern projectile-event-handler function) ;; (function process int symbol event-message-block projectile :behavior projectile)
|
|
;; (define-extern projectile-move-fill-all-dirs function) ;; (function projectile none)
|
|
;; (define-extern projectile-move-fill-line-sphere function) ;; (function projectile none)
|
|
;; (define-extern projectile-update-velocity-add-gravity function) ;; (function projectile none)
|
|
;; (define-extern projectile-update-velocity-space-wars function) ;; (function projectile none)
|
|
;; (define-extern projectile-init-by-other function) ;; (function projectile-init-by-other-params projectile :behavior projectile)
|
|
;; (define-extern projectile-bounce-update-velocity function) ;; (function projectile-bounce none :behavior projectile)
|
|
;; (define-extern projectile-bounce-falling-post function) ;; (function none :behavior projectile-bounce)
|
|
;; (define-extern projectile-bounce-move function) ;; (function projectile-bounce none)
|
|
;; (define-extern projectile-bounce-reaction function) ;; (function control-info collide-query vector vector collide-status)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ragdoll ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern ragdoll-matrix-interp function)
|
|
;; (define-extern ragdoll-joint-callback function)
|
|
;; (define-extern ragdoll-other-joint-callback function)
|
|
;; (define-extern ragdoll-reflect-matrix function)
|
|
;; (define-extern ragdoll-proc-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ragdoll-edit ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern matrix->axis-angle function)
|
|
;; (define-extern show-maya-skeleton function)
|
|
;; (define-extern ragdoll-print-default-joints function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; templex-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tpl-inner-airlock-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wascity-ocean ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ocean-colors-wascity* object)
|
|
;; (define-extern *ocean-near-indices-wascity* ocean-near-indices)
|
|
;; (define-extern *ocean-trans-indices-wascity* ocean-trans-indices)
|
|
;; (define-extern *ocean-mid-indices-wascity* ocean-mid-indices)
|
|
;; (define-extern *ocean-mid-masks-wascity* ocean-mid-masks)
|
|
;; (define-extern *ocean-map-wascity* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyinda-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ctyinda-vingate (elec-gate)
|
|
()
|
|
:method-count-assert 31
|
|
:size-assert #x200
|
|
:flag-assert #x1f01800200
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype industrial-board-vent (bouncer)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xd8
|
|
:flag-assert #x1b006000d8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyinda-evil-streetlamp (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *vingate-elec-gate-params* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lightjak-wings ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wings-ragdoll (ragdoll)
|
|
((which-chain int8 :offset-assert 11980)
|
|
(chain-pos int8 :offset-assert 11981)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x2ece
|
|
:flag-assert #x1a00002ece
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *jchar-wings-ragdoll-setup* object)
|
|
;; (define-extern wings-post function)
|
|
;; (define-extern wings-init function)
|
|
;; (define-extern wings-ragdoll-proc-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-handler ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern target-shoved function) ;; (function meters meters process (state object object target) object :behavior target)
|
|
;; (define-extern attack-mode-is-invinc function) ;; (function symbol symbol)
|
|
;; (define-extern target-attacked function) ;; (function symbol attack-info process touching-shapes-entry (state symbol attack-info target) object :behavior target)
|
|
;; (define-extern target-got-impact-impulse function)
|
|
;; (define-extern target-darkjak-effect-trans function)
|
|
;; (define-extern target-send-attack function) ;; (function process symbol touching-shapes-entry int int penetrate symbol :behavior target)
|
|
;; (define-extern target-generic-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-standard-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-dangerous-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-bonk-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-jump-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-walk-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-exit function) ;; (function none :behavior target)
|
|
;; (define-extern target-state-hook-exit function) ;; (function none :behavior target)
|
|
;; (define-extern target-effect-exit function) ;; (function none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-anim ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern target-land-anim function) ;; (function art-element :behavior target)
|
|
;; (define-extern target-stance-anim function) ;; (function none :behavior target)
|
|
;; (define-extern target-stance-push function) ;; (function int none :behavior target)
|
|
;; (define-extern target-falling-anim function) ;; (function int time-frame symbol :behavior target)
|
|
;; (define-extern target-falling-anim-trans function) ;; (function none :behavior target)
|
|
;; (define-extern target-walk-anim function) ;; (function int none :behavior target)
|
|
;; (define-extern target-hit-ground-flop-anim function) ;; (function symbol symbol none :behavior target)
|
|
;; (define-extern target-hit-ground-anim function) ;; (function symbol symbol none :behavior target)
|
|
;; (define-extern target-attack-air-anim function) ;; (function none :behavior target)
|
|
;; (define-extern target-edge-grab-anim function) ;; (function float none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *trip-mods* object) ;; surface
|
|
;; (define-extern *look-around-mods* object) ;; surface
|
|
;; (define-extern *hit-ground-hard-mods* object) ;; surface
|
|
;; (define-extern *hide-mods* surface) ;; surface
|
|
;; (define-extern *float-mods* object) ;; surface
|
|
;; (define-extern *blast-recover-mods* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-lightjak ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype freeze-screen (process-drawable)
|
|
((anim-frame float :offset-assert 200)
|
|
(transition float :offset-assert 204)
|
|
(gui-id-1 uint32 :offset-assert 208)
|
|
(gui-id-2 uint32 :offset-assert 212)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xd8
|
|
:flag-assert #x19006000d8
|
|
(:methods
|
|
(freeze-screen-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
deactive ;; 22
|
|
die ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype freeze-control (process)
|
|
((clock-pos float :offset-assert 128)
|
|
(freeze-screen uint64 :offset-assert 136)
|
|
(sound-id uint32 :offset-assert 144)
|
|
(tick-time uint64 :offset-assert 152)
|
|
(abort? basic :offset-assert 160)
|
|
(freeze-id uint32 :offset-assert 164)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #xa8
|
|
:flag-assert #xf003000a8
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype freeze-watcher (process)
|
|
((old-clock basic :offset-assert 128)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x84
|
|
:flag-assert #xf00100084
|
|
(:state-methods
|
|
active ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern point-off-screen function)
|
|
;; (define-extern *lightjak-trans-mods* object)
|
|
;; (define-extern want-to-powerjak? function)
|
|
;; (define-extern target-lightjak-setup function)
|
|
;; (define-extern want-to-lightjak? function)
|
|
;; (define-extern target-lightjak-end-mode function)
|
|
;; (define-extern target-lightjak-do-effect function)
|
|
;; (define-extern target-lightjak-process function)
|
|
;; (define-extern *lightjak-swoop-mods* surface)
|
|
;; (define-extern freeze-screen-init function)
|
|
;; (define-extern freeze-control-init function)
|
|
;; (define-extern freeze-watcher-init function)
|
|
;; (define-extern freeze-hit-begin function)
|
|
;; (define-extern freeze-hit-end function)
|
|
;; (define-extern *heal-mods* object)
|
|
;; (define-extern lightjak-shield-init function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; base-plat ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype base-plat (process-focusable)
|
|
((smush smush-control :inline :offset-assert 208)
|
|
(basetrans vector :inline :offset-assert 240)
|
|
(bounce-time uint64 :offset-assert 256) ;; time-frame
|
|
(bouncing symbol :offset-assert 264) ;; guessed by decompiler
|
|
(bounce-scale meters :offset-assert 268)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x110
|
|
:flag-assert #x2300900110
|
|
(:methods
|
|
(base-plat-method-28 () none) ;; 28 ;; (stop-bouncing! (_type_) none 28)
|
|
(base-plat-method-29 () none) ;; 29 ;; (start-bouncing! (_type_) none 29)
|
|
(base-plat-method-30 () none) ;; 30 ;; (get-art-group (_type_) art-group 30)
|
|
(base-plat-method-31 () none) ;; 31 ;; (init-plat-collision! (_type_) none 31)
|
|
(base-plat-method-32 () none) ;; 32 ;; (base-plat-method-32 (_type_) none 32)
|
|
(base-plat-method-33 () none) ;; 33 ;; (init-plat! (_type_) none 33)
|
|
(base-plat-method-34 () none) ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eco-door (process-drawable)
|
|
((speed float :offset-assert 200)
|
|
(open-distance float :offset-assert 204)
|
|
(close-distance float :offset-assert 208)
|
|
(out-dir vector :inline :offset-assert 224)
|
|
(open-sound uint128 :offset-assert 240) ;; sound-name
|
|
(close-sound uint128 :offset-assert 256) ;; sound-name
|
|
(state-actor entity-actor :offset-assert 272) ;; guessed by decompiler
|
|
(flags int32 :offset-assert 276) ;; eco-door-flags
|
|
(locked symbol :offset-assert 280) ;; guessed by decompiler
|
|
(auto-close symbol :offset-assert 284) ;; guessed by decompiler
|
|
(one-way symbol :offset-assert 288) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #x124
|
|
:flag-assert #x1b00b00124
|
|
(:methods
|
|
(eco-door-method-24 () none) ;; 24 ;; (lock-according-to-task! (_type_) none 24)
|
|
(eco-door-method-25 () none) ;; 25 ;; (eco-door-method-25 (_type_) none 25)
|
|
(eco-door-method-26 () none) ;; 26 ;; (stub (_type_) none 26)
|
|
)
|
|
(:state-methods
|
|
door-closed ;; 20, old: (door-closed () _type_ :state 20)
|
|
door-opening ;; 21, old: (door-opening () _type_ :state 21)
|
|
door-open ;; 22, old: (door-open () _type_ :state 22)
|
|
door-closing ;; 23, old: (door-closing () _type_ :state 23)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern plat-code function) ;; (function none :behavior base-plat)
|
|
;; (define-extern plat-trans function) ;; (function none :behavior base-plat)
|
|
;; (define-extern plat-post function) ;; (function none :behavior base-plat)
|
|
;; (define-extern plat-event function) ;; (function process int symbol event-message-block object :behavior base-plat)
|
|
;; (define-extern eco-door-event-handler function) ;; (function process int symbol event-message-block object :behavior eco-door)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; race-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern race-find-ground function) ;; (function vector vector symbol)
|
|
;; (define-extern *race-state* object) ;; race-state
|
|
;; (define-extern *race-rigid-body-queue* object) ;; rigid-body-queue
|
|
;; (define-extern race-manager-event-handler function) ;; (function process int symbol event-message-block object :behavior race-manager)
|
|
;; (define-extern race-manager-init-by-other function) ;; (function race-info symbol none :behavior race-manager)
|
|
;; (define-extern race-start function) ;; (function int process symbol process)
|
|
;; (define-extern race-kill function) ;; (function none)
|
|
;; (define-extern race-vehicle-entity-hack function) ;; (function none)
|
|
;; (define-extern race-level-activate function) ;; (function level none)
|
|
;; (define-extern race-level-deactivate function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desresc-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *desresc-warp-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-invisible ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype invis-particle-joint (structure)
|
|
((joint int16 :offset-assert 0)
|
|
(distance float :offset-assert 4)
|
|
(size float :offset-assert 8)
|
|
(spawn? basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dark-maker-idol (process-drawable)
|
|
((humming-sound basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern target-invisible-start function)
|
|
;; (define-extern target-invisible-stop function)
|
|
;; (define-extern *invis-joint-list* array)
|
|
;; (define-extern target-invisible-process function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-launch ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-gun ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *gun-walk-mods* surface) ;; surface
|
|
;; (define-extern want-to-gun? function) ;; (function target symbol symbol :behavior process)
|
|
;; (define-extern target-gun-event-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-gun-setup function) ;; (function symbol none :behavior target)
|
|
;; (define-extern target-gun-init function) ;; (function pickup-type none :behavior target)
|
|
;; (define-extern target-gun-exit function) ;; (function symbol)
|
|
;; (define-extern target-gun-end-mode function) ;; (function symbol symbol :behavior target)
|
|
;; (define-extern quat<-gun! function) ;; (function quaternion quaternion quaternion)
|
|
;; (define-extern target-gun-ammo-out-pick function) ;; (function int :behavior target)
|
|
;; (define-extern target-gun-type-set! function) ;; (function pickup-type none :behavior target)
|
|
;; (define-extern target-gun-marking-menu function) ;; (function target none)
|
|
;; (define-extern target-gun-build-track-list function) ;; (function none :behavior target)
|
|
;; (define-extern target-gun-find-track function) ;; (function none :behavior target)
|
|
;; (define-extern target-top-anim-base-mode function) ;; (function int none :behavior target)
|
|
;; (define-extern target-gun-combo-start function) ;; (function int time-frame none :behavior target)
|
|
;; (define-extern target-gun-joint-pre0 function) ;; (function none :behavior target)
|
|
;; (define-extern target-gun-joint-pre function) ;; (function none :behavior target)
|
|
;; (define-extern target-gun-compute-pos function) ;; (function matrix :behavior target)
|
|
;; (define-extern target-gun-joint-points function) ;; (function none :behavior target)
|
|
;; (define-extern target-gun-fire function) ;; (function pickup-type none :behavior target)
|
|
;; (define-extern target-gun-check function) ;; (function none :behavior target)
|
|
;; (define-extern camera-rotate-to-vector function) ;; (function vector vector none)
|
|
;; (define-extern target-gun-real-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-gun-post function) ;; (function none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; enemy ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *enemy-dummy-shadow-control* shadow-control) ;; shadow-control
|
|
;; (define-extern get-penetrate-using-from-attack-event function) ;; (function process-drawable event-message-block penetrate)
|
|
;; (define-extern enemy-setup-gem function)
|
|
;; (define-extern enemy-init-by-other function) ;; (function process-drawable enemy-init-by-other-params none :behavior enemy)
|
|
;; (define-extern enemy-event-handler function) ;; (function process int symbol event-message-block object :behavior enemy)
|
|
;; (define-extern enemy-simple-post function) ;; (function none :behavior enemy)
|
|
;; (define-extern enemy-falling-post function) ;; (function none :behavior enemy)
|
|
;; (define-extern enemy-die-falling-post function) ;; (function none :behavior enemy)
|
|
;; (define-extern *shockwave-knock-scalar* curve2d-fast)
|
|
;; (define-extern ja-group-index? function) ;; (function int symbol :behavior enemy)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; terraformer-setup ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype terraformer-foot-mark-pt (structure)
|
|
((collision-pt vector :inline :offset-assert 0)
|
|
(normal vector :inline :offset-assert 16)
|
|
(found? basic :offset-assert 32)
|
|
(angle float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-foot-mark-pt-array (basic)
|
|
((points UNKNOWN 20 :offset-assert 16)
|
|
(origin vector :inline :offset-assert 976)
|
|
(radius float :offset-assert 992)
|
|
(current-point int32 :offset-assert 996)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x3e8
|
|
:flag-assert #xc000003e8
|
|
(:methods
|
|
(terraformer-foot-mark-pt-array-method-9 () none) ;; 9
|
|
(terraformer-foot-mark-pt-array-method-10 () none) ;; 10
|
|
(terraformer-foot-mark-pt-array-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-node (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(edge-index int16 :offset-assert 16)
|
|
(edge-count int16 :offset-assert 18)
|
|
(pos-x float :offset-assert 0)
|
|
(pos-y float :offset-assert 4)
|
|
(pos-z float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-edge (structure)
|
|
((dest-node-id uint16 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-graph (structure)
|
|
((node-count uint16 :offset-assert 0)
|
|
(edge-count uint16 :offset-assert 2)
|
|
(node uint32 :offset-assert 4)
|
|
(edge uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-ik-setup (structure)
|
|
((elbow-index int32 :offset-assert 0)
|
|
(hand-dist float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-foot-lock (structure)
|
|
((lock cam-float-seeker :inline :offset-assert 0)
|
|
(old-position vector :inline :offset-assert 32)
|
|
(old-normal vector :inline :offset-assert 48)
|
|
(initialized basic :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer (process-drawable)
|
|
((graph terraformer-graph :offset-assert 200)
|
|
(current-node uint16 :offset-assert 204)
|
|
(legs UNKNOWN 6 :offset-assert 208)
|
|
(mine-timer uint64 :offset-assert 256)
|
|
(mines-to-launch int8 :offset-assert 264)
|
|
(launch-drones basic :offset-assert 268)
|
|
(old-target-pos vector :inline :offset-assert 272)
|
|
(old-target-time uint64 :offset-assert 288)
|
|
(older-target-pos vector :inline :offset-assert 304)
|
|
(older-target-time uint64 :offset-assert 320)
|
|
(anim-speed float :offset-assert 328)
|
|
(spooled-anim basic :offset-assert 332)
|
|
(desired-nav-mesh-index int8 :offset-assert 336)
|
|
(current-nav-mesh-index int8 :offset-assert 337)
|
|
(mines UNKNOWN 10 :offset-assert 344)
|
|
(jumper uint64 :offset-assert 424)
|
|
(drone uint64 :offset-assert 432)
|
|
(drone-time uint64 :offset-assert 440)
|
|
(jump-dest vector :inline :offset-assert 448)
|
|
(target-rot matrix :inline :offset-assert 464)
|
|
(mine-rounds-till-drones int8 :offset-assert 528)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x211
|
|
:flag-assert #x1a01a00211
|
|
(:state-methods
|
|
dormant ;; 20
|
|
frozen ;; 21
|
|
walk ;; 25
|
|
scrub-anim ;; 24
|
|
idle ;; 23
|
|
stand-still-laddie! ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-mine (process-focusable)
|
|
((src-pos vector :inline :offset-assert 208)
|
|
(dest-pos vector :inline :offset-assert 224)
|
|
(traj trajectory :inline :offset-assert 240)
|
|
(which-trajectory int8 :offset-assert 280)
|
|
(x-rotate float :offset-assert 284)
|
|
(y-rotate float :offset-assert 288)
|
|
(trail-part basic :offset-assert 292)
|
|
(incoming-sound-played basic :offset-assert 296)
|
|
(expand-sound-played basic :offset-assert 300)
|
|
(exploded basic :offset-assert 304)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x134
|
|
:flag-assert #x1e00c00134
|
|
(:state-methods
|
|
idle ;; 28
|
|
fly-to-dest ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-target (process-focusable)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #xd0
|
|
:flag-assert #x1d005000d0
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-leg-minimap-dot (process-drawable)
|
|
((minimap connection-minimap :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-foot-water-splash (structure)
|
|
((frame float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-leg (process-drawable)
|
|
((prefix basic :offset-assert 200)
|
|
(kind int8 :offset-assert 204)
|
|
(side int8 :offset-assert 205)
|
|
(targets UNKNOWN 6 :offset-assert 208)
|
|
(mm-handle uint64 :offset-assert 256)
|
|
(joint-ik basic :offset-assert 264)
|
|
(foot-lock terraformer-foot-lock :inline :offset-assert 272)
|
|
(foot-marks basic :offset-assert 340)
|
|
(collision-disable-timer uint64 :offset-assert 344)
|
|
(foot-up-frame float :offset-assert 352)
|
|
(last-effect int8 :offset-assert 356)
|
|
(sand-drop-part basic :offset-assert 360)
|
|
(water-drop-part basic :offset-assert 364)
|
|
(splash-list basic :offset-assert 368)
|
|
(splash-list-index int8 :offset-assert 372)
|
|
(stepped-in-water basic :offset-assert 376)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x17c
|
|
:flag-assert #x150100017c
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-terraformer (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-terraformer (task-manager)
|
|
((pilot-mode? basic :offset-assert 240)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xf4
|
|
:flag-assert #x21008000f4
|
|
(:methods
|
|
(task-manager-terraformer-method-32 () none) ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *terraformer-shadow-control* shadow-control)
|
|
;; (define-extern *terraformer-walk-graph* object)
|
|
;; (define-extern *terraformer-ik-setup* object)
|
|
;; (define-extern *terraformer-lf-water-splash-list* array)
|
|
;; (define-extern *terraformer-lm-water-splash-list* array)
|
|
;; (define-extern *terraformer-lr-water-splash-list* array)
|
|
;; (define-extern *terraformer-rf-water-splash-list* array)
|
|
;; (define-extern *terraformer-rm-water-splash-list* array)
|
|
;; (define-extern *terraformer-rr-water-splash-list* array)
|
|
;; (define-extern terraformer-leg-minimap-dot-init-by-other function)
|
|
;; (define-extern terraformer-mine-init-by-other function)
|
|
;; (define-extern terraformer-mine-explode function)
|
|
;; (define-extern terraformer-mine-handler function)
|
|
;; (define-extern terraformer-target-init-by-other function)
|
|
;; (define-extern terraformer-leg-frames-since-lift function)
|
|
;; (define-extern terraformer-leg-frames-till-down function)
|
|
;; (define-extern terraformer-leg-frames-till-up function)
|
|
;; (define-extern terraformer-leg-should-be-up? function)
|
|
;; (define-extern terraformer-leg-init-by-other function)
|
|
;; (define-extern foot-impact function)
|
|
;; (define-extern ik-adjust function) ;; (function float :behavior metalkor-legs)
|
|
;; (define-extern terraformer-leg-deadly? function)
|
|
;; (define-extern terraformer-leg-update-ik function)
|
|
;; (define-extern terraformer-always function)
|
|
;; (define-extern find-mine-dest function)
|
|
;; (define-extern launch-mine function)
|
|
;; (define-extern terraformer-init-mine-vars function)
|
|
;; (define-extern terraformer-update-mine-vars function)
|
|
;; (define-extern terraformer-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-util ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gun-eject (projectile-bounce)
|
|
()
|
|
:method-count-assert 44
|
|
:size-assert #x224
|
|
:flag-assert #x2c01b00224
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-mag-yellow (projectile-bounce)
|
|
()
|
|
:method-count-assert 44
|
|
:size-assert #x224
|
|
:flag-assert #x2c01b00224
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-mag-red (projectile-bounce)
|
|
()
|
|
:method-count-assert 44
|
|
:size-assert #x224
|
|
:flag-assert #x2c01b00224
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-mag-blue (projectile-bounce)
|
|
()
|
|
:method-count-assert 44
|
|
:size-assert #x224
|
|
:flag-assert #x2c01b00224
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-mag-dark (projectile-bounce)
|
|
()
|
|
:method-count-assert 44
|
|
:size-assert #x224
|
|
:flag-assert #x2c01b00224
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype last-gun-fire-time (structure)
|
|
((last-fire-times UNKNOWN 12 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *beam-info* object) ;; beam-info
|
|
;; (define-extern birth-func-setup-beam function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern birth-func-laser-pointer function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern draw-beam function) ;; (function sparticle-launcher vector vector symbol symbol none)
|
|
;; (define-extern gun-post function) ;; (function none :behavior gun)
|
|
;; (define-extern gun-init function) ;; (function none :behavior gun)
|
|
;; (define-extern do-fire-backcheck function)
|
|
;; (define-extern get-remaining-player-ammo function)
|
|
;; (define-extern adjust-player-ammo function)
|
|
;; (define-extern adjust-player-ammo-over-time function)
|
|
;; (define-extern truncate-player-ammo function)
|
|
;; (define-extern *last-gun-fire-time* object)
|
|
;; (define-extern compute-gun-fire-time-index function)
|
|
;; (define-extern get-last-fire-time function)
|
|
;; (define-extern set-last-fire-time function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-yellow-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gun-yellow-shot (projectile)
|
|
((hit-actor? symbol :offset-assert 512) ;; guessed by decompiler
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
(hit-pos vector :inline :offset-assert 544)
|
|
(last-hit-time uint64 :offset-assert 560)
|
|
(snd-whoosh uint32 :offset-assert 568)
|
|
(muzzle-flash-part basic :offset-assert 572)
|
|
(main-shot-part basic :offset-assert 576)
|
|
(shot-aim-part basic :offset-assert 580)
|
|
(shot-ring-part basic :offset-assert 584)
|
|
)
|
|
:method-count-assert 44
|
|
:size-assert #x24c
|
|
:flag-assert #x2c01d0024c
|
|
(:methods
|
|
(gun-yellow-shot-method-41 () none) ;; 41
|
|
(gun-yellow-shot-method-42 () none) ;; 42
|
|
(gun-yellow-shot-method-43 () none) ;; 43
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-yellow-2-proc-ignore (structure)
|
|
((hand uint64 :offset-assert 0)
|
|
(time uint64 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-yellow-shot-2 (gun-yellow-shot)
|
|
((last-collide-time uint64 :offset-assert 592)
|
|
(snd-trail uint32 :offset-assert 600)
|
|
(hit-yet? basic :offset-assert 604)
|
|
(actor-deflect? basic :offset-assert 608)
|
|
(max-actor-deflect-count int32 :offset-assert 612)
|
|
(last-hit-enemy uint64 :offset-assert 616)
|
|
(delay-attack uint64 :offset-assert 624)
|
|
(delay-norm vector :inline :offset-assert 640)
|
|
(enemy-hit-count int32 :offset-assert 656)
|
|
(ignore-list UNKNOWN 6 :offset-assert 664)
|
|
(last-attack-time uint64 :offset-assert 760)
|
|
)
|
|
:method-count-assert 48
|
|
:size-assert #x300
|
|
:flag-assert #x3002800300
|
|
(:methods
|
|
(gun-yellow-shot-2-method-44 () none) ;; 44
|
|
(gun-yellow-shot-2-method-45 () none) ;; 45
|
|
(gun-yellow-shot-2-method-46 () none) ;; 46
|
|
(gun-yellow-shot-2-method-47 () none) ;; 47
|
|
)
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-yellow-shot-3 (gun-yellow-shot)
|
|
()
|
|
:method-count-assert 44
|
|
:size-assert #x24c
|
|
:flag-assert #x2c01d0024c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-yellow-3-saucer (projectile-bounce)
|
|
((total-float-time uint64 :offset-assert 552)
|
|
(state-time uint64 :offset-assert 192)
|
|
(firing? basic :offset-assert 568)
|
|
(asleep? basic :offset-assert 572)
|
|
(first-fire-time uint64 :offset-assert 576)
|
|
(activated? basic :offset-assert 584)
|
|
(collided-with-surface? basic :offset-assert 588)
|
|
(last-deflect-time uint64 :offset-assert 592)
|
|
(last-fire-time uint64 :offset-assert 600)
|
|
(spawn-part basic :offset-assert 608)
|
|
(last-blink-time uint64 :offset-assert 616)
|
|
(finished? basic :offset-assert 624)
|
|
(initial-fire-dir vector :inline :offset-assert 640)
|
|
(initial-fire-pos vector :inline :offset-assert 656)
|
|
(last-deduct-ammo-time uint64 :offset-assert 672)
|
|
(total-ammo-drained float :offset-assert 680)
|
|
(total-ammo-to-drain float :offset-assert 684)
|
|
(total-fire-time uint64 :offset-assert 688)
|
|
(snd-hum uint32 :offset-assert 696)
|
|
(snd-shoot uint32 :offset-assert 700)
|
|
)
|
|
:method-count-assert 54
|
|
:size-assert #x2c0
|
|
:flag-assert #x36024002c0
|
|
(:methods
|
|
(gun-yellow-3-saucer-method-44 () none) ;; 44
|
|
(gun-yellow-3-saucer-method-50 () none) ;; 50
|
|
(gun-yellow-3-saucer-method-51 () none) ;; 51
|
|
(gun-yellow-3-saucer-method-52 () none) ;; 52
|
|
(gun-yellow-3-saucer-method-53 () none) ;; 53
|
|
)
|
|
(:state-methods
|
|
sitting ;; 41
|
|
burnt-husk ;; 49
|
|
falling-down ;; 48
|
|
impact-explode ;; 47
|
|
moving ;; 23
|
|
navigating ;; 45
|
|
spinning ;; 46
|
|
)
|
|
(:states
|
|
gun-yellow-3-saucer-base-state
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype target-quality-info-saucer (structure)
|
|
((targ uint64 :offset-assert 0)
|
|
(value float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-yellow-3-event-msg (structure)
|
|
((activated? basic :offset-assert 0)
|
|
(finished? basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern saucer-land-move function)
|
|
;; (define-extern gun-fire-yellow-3 function)
|
|
;; (define-extern gun-fire-yellow-2 function)
|
|
;; (define-extern gun-fire-yellow-1 function)
|
|
;; (define-extern target-gun-can-fire-yellow? function)
|
|
;; (define-extern target-gun-fire-yellow function) ;; (function (pointer process) :behavior target)
|
|
;; (define-extern someone-fire-yellow function) ;; (function process-drawable vector vector (pointer process))
|
|
;; (define-extern gun-yellow-shot-move function) ;; (function gun-yellow-shot none)
|
|
;; (define-extern *last-hit-deflect-target-handle* object)
|
|
;; (define-extern gun-yellow-shot-do-deflect function)
|
|
;; (define-extern gun-yellow-deflect-reaction function)
|
|
;; (define-extern gun-yellow-shot-2-move function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-red-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gun-red-shot (process-drawable)
|
|
((probe-count int32 :offset-assert 200)
|
|
(probe-mask uint32 :offset-assert 204)
|
|
(actor-count int32 :offset-assert 208)
|
|
(attack-id uint32 :offset-assert 212)
|
|
(start-pos vector :inline :offset-assert 224)
|
|
(start-dir vector :inline :offset-assert 240)
|
|
(start-rot vector :inline :offset-assert 256)
|
|
(probe-dir vector 19 :offset-assert 272) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x240
|
|
:flag-assert #x1e01c00240
|
|
(:methods
|
|
(gun-red-shot-method-23 () none) ;; 23 ;; (init-probes! (_type_ collide-shape) none 23)
|
|
(gun-red-shot-method-24 () none) ;; 24 ;; (gun-red-shot-method-24 (_type_) symbol 24)
|
|
(gun-red-shot-method-25 () none) ;; 25 ;; (noop (_type_) none 25)
|
|
(gun-red-shot-method-26 () none) ;; 26 ;; (gun-red-shot-method-26 (_type_) none 26)
|
|
(gun-red-shot-method-27 () none) ;; 27 ;; (gun-red-shot-method-27 (_type_) none 27)
|
|
(gun-red-shot-method-28 () none) ;; 28 ;; (gun-red-shot-method-28 (_type_ vector) sound-id 28)
|
|
(gun-red-shot-method-29 () none) ;; 29 ;; (fire! (_type_ process-drawable int) object 29)
|
|
)
|
|
(:state-methods
|
|
debug-idle ;; 21, old: (debug-idle () _type_ :state 21)
|
|
blocked ;; 20, old: (blocked () _type_ :state 20)
|
|
idle ;; 22, old: (idle () _type_ :state 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-red-3-grenade (projectile-bounce)
|
|
((blast-radius float :offset-assert 548)
|
|
(should-explode-soon? basic :offset-assert 552)
|
|
(explode-tick-time uint64 :offset-assert 560)
|
|
(birth-time uint64 :offset-assert 568)
|
|
(immediate-detonation? basic :offset-assert 576)
|
|
(attack-id uint32 :offset-assert 444)
|
|
(explode-delay-time uint64 :offset-assert 584)
|
|
)
|
|
:method-count-assert 48
|
|
:size-assert #x250
|
|
:flag-assert #x3001d00250
|
|
(:methods
|
|
(gun-red-3-grenade-method-45 () none) ;; 45
|
|
(gun-red-3-grenade-method-46 () none) ;; 46
|
|
(gun-red-3-grenade-method-47 () none) ;; 47
|
|
)
|
|
(:state-methods
|
|
moving ;; 23
|
|
sitting ;; 41
|
|
impact-tiny ;; 44
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shockwave-collision-pt (structure)
|
|
((collision-pt vector :inline :offset-assert 0)
|
|
(normal vector :inline :offset-assert 16)
|
|
(found? basic :offset-assert 32)
|
|
(angle float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-red-2-shockwave (process)
|
|
((origin vector :inline :offset-assert 128)
|
|
(max-radius float :offset-assert 144)
|
|
(strength float :offset-assert 148)
|
|
(current-radius float :offset-assert 152)
|
|
(current-intensity float :offset-assert 156)
|
|
(state-time uint64 :offset-assert 160)
|
|
(alpha-scalar float :offset-assert 168)
|
|
(base-damage float :offset-assert 172)
|
|
(snd-charge uint32 :offset-assert 176)
|
|
(min-charge-radius float :offset-assert 180)
|
|
(max-charge-radius float :offset-assert 184)
|
|
(total-charge-time uint64 :offset-assert 192)
|
|
(total-explode-time uint64 :offset-assert 200)
|
|
(ring-expansion-time uint64 :offset-assert 208)
|
|
(burst-expansion-time uint64 :offset-assert 216)
|
|
(warp-expansion-time uint64 :offset-assert 224)
|
|
(previously-attacked-targets UNKNOWN 64 :offset-assert 232)
|
|
(num-previously-attacked-targets int8 :offset-assert 744)
|
|
(start-pilot? basic :offset-assert 748)
|
|
(explosion-0 uint64 :offset-assert 752)
|
|
(explosion-1 uint64 :offset-assert 760)
|
|
(generate-order-array UNKNOWN 127 :offset-assert 768)
|
|
(current-stage-t float :offset-assert 896)
|
|
(ammo-drained float :offset-assert 900)
|
|
(eventual-collision-points UNKNOWN 128 :offset-assert 912)
|
|
(next-computed-collision-point int8 :offset-assert 7056)
|
|
(num-collision-pts-to-generate int8 :offset-assert 7057)
|
|
(show-scorch-marks? basic :offset-assert 7060)
|
|
(height-off-ground float :offset-assert 7064)
|
|
(max-ground-radius float :offset-assert 7068)
|
|
(current-ring-radius float :offset-assert 7072)
|
|
(current-ring-alpha float :offset-assert 7076)
|
|
(current-warp-radius float :offset-assert 7080)
|
|
(current-warp-alpha float :offset-assert 7084)
|
|
(current-burst-radius float :offset-assert 7088)
|
|
(current-burst-alpha float :offset-assert 7092)
|
|
(generating-marks? basic :offset-assert 7096)
|
|
(generated-particles? basic :offset-assert 7100)
|
|
(charge-part-tracker uint64 :offset-assert 7104)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #x1bc8
|
|
:flag-assert #x1c1b501bc8
|
|
(:methods
|
|
(gun-red-2-shockwave-method-17 () none) ;; 17
|
|
(gun-red-2-shockwave-method-18 () none) ;; 18
|
|
(gun-red-2-shockwave-method-19 () none) ;; 19
|
|
(gun-red-2-shockwave-method-20 () none) ;; 20
|
|
(gun-red-2-shockwave-method-21 () none) ;; 21
|
|
(gun-red-2-shockwave-method-22 () none) ;; 22
|
|
(gun-red-2-shockwave-method-23 () none) ;; 23
|
|
(gun-red-2-shockwave-method-24 () none) ;; 24
|
|
(gun-red-2-shockwave-method-25 () none) ;; 25
|
|
(gun-red-2-shockwave-method-26 () none) ;; 26
|
|
(gun-red-2-shockwave-method-27 () none) ;; 27
|
|
)
|
|
(:state-methods
|
|
charging ;; 14
|
|
die ;; 16
|
|
explode ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-red-2-shockwave-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(max-radius float :offset-assert 16)
|
|
(strength float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-red-2-explosion (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:methods
|
|
(gun-red-2-explosion-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype red-2-ring (process-drawable)
|
|
((current-alpha float :offset-assert 200)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd8
|
|
:flag-assert #x17006000d8
|
|
(:methods
|
|
(red-2-ring-method-21 () none) ;; 21
|
|
(red-2-ring-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype red-2-ring-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype red-3-sphere (process-drawable)
|
|
((current-alpha float :offset-assert 200)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd8
|
|
:flag-assert #x17006000d8
|
|
(:methods
|
|
(red-3-sphere-method-21 () none) ;; 21
|
|
(red-3-sphere-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype red-3-sphere-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern part-tracker-move-to-target-gun function)
|
|
;; (define-extern gun-red-2-shockwave-init-by-other function)
|
|
;; (define-extern generate-shockwave-scorch-marks-3 function)
|
|
;; (define-extern generate-shockwave-scorch-marks-2 function)
|
|
;; (define-extern red-2-ring-event-handler function)
|
|
;; (define-extern red-2-ring-init-by-other function)
|
|
;; (define-extern *impact-blur* object)
|
|
;; (define-extern *shockwave-blur-red-2* object)
|
|
;; (define-extern gun-fire-red-2 function)
|
|
;; (define-extern red-3-sphere-init-by-other function)
|
|
;; (define-extern gun-fire-red-3 function)
|
|
;; (define-extern gun-fire-red-1 function)
|
|
;; (define-extern target-gun-can-fire-red? function)
|
|
;; (define-extern target-gun-fire-red function) ;; (function (pointer gun-red-shot) :behavior target)
|
|
;; (define-extern gun-red-shot-event-handler function) ;; (function process-drawable int symbol event-message-block object :behavior gun-red-shot)
|
|
;; (define-extern gun-red-shot-init-by-other function) ;; (function vector vector gun-red-shot :behavior gun-red-shot)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-dark-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gun-dark-shot (projectile)
|
|
((blast-radius float :offset-assert 512)
|
|
(core-position vector :inline :offset-assert 528)
|
|
(core-velocity vector :inline :offset-assert 544)
|
|
(spin-vector vector :inline :offset-assert 560)
|
|
(track-target uint64 :offset-assert 576) ;; handle
|
|
(size-t float :offset-assert 584)
|
|
(result-array handle 16 :offset-assert 592) ;; guessed by decompiler
|
|
(result-count int8 :offset-assert 720)
|
|
(charge-sound sound-id :offset-assert 724) ;; guessed by decompiler
|
|
(fire-sound sound-id :offset-assert 728) ;; guessed by decompiler
|
|
(trail-sound sound-id :offset-assert 732) ;; guessed by decompiler
|
|
(explode-sound sound-id :offset-assert 736) ;; guessed by decompiler
|
|
(start-pilot? basic :offset-assert 740)
|
|
(spread-timer uint64 :offset-assert 744)
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x2f0
|
|
:flag-assert #x2b027002f0
|
|
(:state-methods
|
|
startup ;; 41, old: (fizzle () _type_ :state 41)
|
|
moving ;; 23
|
|
fizzle ;; 42
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dark-3-sphere (process-drawable)
|
|
((alpha-val float :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dark-3-sphere-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(size-x float :offset-assert 16)
|
|
(size-y float :offset-assert 20)
|
|
(alpha-val float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype last-active-nuke-info (structure)
|
|
((last-active-nuke uint64 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dark-3-nuke (projectile)
|
|
((flash-time uint64 :offset-assert 512)
|
|
(blur-time uint64 :offset-assert 520)
|
|
(spawned-mushroom-cloud? basic :offset-assert 528)
|
|
(strip basic :offset-assert 532)
|
|
(mushroom-top-pos vector :inline :offset-assert 544)
|
|
(warp uint64 :offset-assert 560)
|
|
(initial-velocity vector :inline :offset-assert 576)
|
|
(start-y float :offset-assert 592)
|
|
(y-vel-adjust float :offset-assert 596)
|
|
(launch-speed float :offset-assert 600)
|
|
(launch-sin-region-start float :offset-assert 604)
|
|
(launch-sin-region-end float :offset-assert 608)
|
|
(launch-stay-state-time uint64 :offset-assert 616)
|
|
(launch-next-state basic :offset-assert 624)
|
|
(launch-impact-state basic :offset-assert 628)
|
|
(launch-y-scale float :offset-assert 632)
|
|
(launch-height-t float :offset-assert 636)
|
|
(expected-height float :offset-assert 640)
|
|
(total-fly-time uint64 :offset-assert 648)
|
|
(num-dying-vehicles uint8 :offset-assert 656)
|
|
(num-dying-guards uint8 :offset-assert 657)
|
|
(num-dying-civilians uint8 :offset-assert 658)
|
|
(last-death-sound-play-time uint64 :offset-assert 664)
|
|
(blur-curve basic :offset-assert 672)
|
|
(fade-curve basic :offset-assert 676)
|
|
(num-blur-segments uint8 :offset-assert 680)
|
|
(shook-camera? basic :offset-assert 684)
|
|
(hit-wall? basic :offset-assert 688)
|
|
(killed-everything? basic :offset-assert 696)
|
|
(explode-sound uint32 :offset-assert 700)
|
|
(explode-wall-sound uint32 :offset-assert 704)
|
|
(played-trail? basic :offset-assert 708)
|
|
(smoke-trail basic :offset-assert 712)
|
|
(killed-objects UNKNOWN 64 :offset-assert 720)
|
|
(num-killed-objects int32 :offset-assert 1232)
|
|
(last-kill-time uint64 :offset-assert 1240)
|
|
)
|
|
:method-count-assert 60
|
|
:size-assert #x4e0
|
|
:flag-assert #x3c046004e0
|
|
(:methods
|
|
(gun-dark-3-nuke-method-41 () none) ;; 41
|
|
(gun-dark-3-nuke-method-51 () none) ;; 51
|
|
(gun-dark-3-nuke-method-52 () none) ;; 52
|
|
(gun-dark-3-nuke-method-53 () none) ;; 53
|
|
(gun-dark-3-nuke-method-54 () none) ;; 54
|
|
(gun-dark-3-nuke-method-55 () none) ;; 55
|
|
(gun-dark-3-nuke-method-56 () none) ;; 56
|
|
(gun-dark-3-nuke-method-57 () none) ;; 57
|
|
(gun-dark-3-nuke-method-58 () none) ;; 58
|
|
(gun-dark-3-nuke-method-59 () none) ;; 59
|
|
)
|
|
(:state-methods
|
|
launching-base-state ;; 42
|
|
launch-0 ;; 43
|
|
launch-1 ;; 44
|
|
launch-2 ;; 45
|
|
launch-3 ;; 46
|
|
impact-dud ;; 48
|
|
impact-embedded ;; 49
|
|
impact-small ;; 47
|
|
wait-for-alive ;; 50
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gravity-spinner (process)
|
|
((cached-damage float :offset-assert 128)
|
|
(end-time uint64 :offset-assert 136)
|
|
(time-subtract uint64 :offset-assert 144)
|
|
(parent-hand uint64 :offset-assert 152)
|
|
(rotation-accel vector :inline :offset-assert 160)
|
|
(original-sphere-offset sphere :inline :offset-assert 176)
|
|
(obj-radius float :offset-assert 192)
|
|
(was-hit-previously? basic :offset-assert 196)
|
|
(ground-height float :offset-assert 200)
|
|
(next-ground-probe-time uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xd8
|
|
:flag-assert #x19006000d8
|
|
(:methods
|
|
(gravity-spinner-method-16 () none) ;; 16
|
|
(gravity-spinner-method-17 () none) ;; 17
|
|
(gravity-spinner-method-18 () none) ;; 18
|
|
(gravity-spinner-method-19 () none) ;; 19
|
|
(gravity-spinner-method-20 () none) ;; 20
|
|
(gravity-spinner-method-21 () none) ;; 21
|
|
(gravity-spinner-method-22 () none) ;; 22
|
|
(gravity-spinner-method-23 () none) ;; 23
|
|
(gravity-spinner-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
zero-g-vehicle ;; 15
|
|
zero-g ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gravity-ring (process-drawable)
|
|
((start-pos vector :inline :offset-assert 208)
|
|
(jmod-outer joint-mod-add-local :inline :offset-assert 224)
|
|
(jmod-inner joint-mod-add-local :inline :offset-assert 288)
|
|
(ring-scale-t float :offset-assert 352)
|
|
(current-radius float :offset-assert 356)
|
|
(max-radius float :offset-assert 360)
|
|
(reverse? basic :offset-assert 364)
|
|
(total-time float :offset-assert 368)
|
|
(ring-width float :offset-assert 372)
|
|
(stop-time uint64 :offset-assert 376)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x180
|
|
:flag-assert #x1601000180
|
|
(:methods
|
|
(gravity-ring-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
expand ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-gravity (process-drawable)
|
|
((current-radius float :offset-assert 200)
|
|
(max-radius float :offset-assert 204)
|
|
(lowest-y float :offset-assert 208)
|
|
(start-pos vector :inline :offset-assert 224)
|
|
(total-time float :offset-assert 240)
|
|
(ring-closest uint64 :offset-assert 248)
|
|
(ring-furthest uint64 :offset-assert 256)
|
|
(gravity-sound uint32 :offset-assert 264)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x10c
|
|
:flag-assert #x190090010c
|
|
(:methods
|
|
(gun-gravity-method-21 () none) ;; 21
|
|
(gun-gravity-method-22 () none) ;; 22
|
|
(gun-gravity-method-23 () none) ;; 23
|
|
(gun-gravity-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
expand ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sparticle-lightning-2d-spline-align-plus-rotz function)
|
|
;; (define-extern gun-fire-dark-1 function)
|
|
;; (define-extern gun-dark-3-sphere-init-by-other function)
|
|
;; (define-extern *last-active-nuke* object)
|
|
;; (define-extern gun-dark-reaction function)
|
|
;; (define-extern nuke-move function)
|
|
;; (define-extern target-gun-can-fire-dark? function)
|
|
;; (define-extern gun-fire-dark-3 function)
|
|
;; (define-extern process-drawable-shock-effect-bullseye function) ;; (function process-focusable process-focusable matrix int sparticle-launcher sparticle-launcher sparticle-launcher none)
|
|
;; (define-extern gun-dark-shot-init-fizzle function) ;; (function vector none :behavior gun-dark-shot)
|
|
;; (define-extern *gravity-origin-pos* object)
|
|
;; (define-extern gravity-spinner-init-by-other function)
|
|
;; (define-extern zero-g-wait-for-land function)
|
|
;; (define-extern *zero-g-fake-attack-vec* object)
|
|
;; (define-extern *gun-gravity-shadow-control* shadow-control)
|
|
;; (define-extern gravity-ring-init-by-other function)
|
|
;; (define-extern gun-gravity-init-by-other function)
|
|
;; (define-extern gun-fire-dark-2 function)
|
|
;; (define-extern target-gun-fire-dark function) ;; (function (pointer process) :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; board-util ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern board-post function) ;; (function none :behavior board)
|
|
;; (define-extern board-init function) ;; (function none :behavior board)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kg-squad-member ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-board ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *board-walk-mods* surface) ;; surface
|
|
;; (define-extern *board-duck-mods* surface) ;; surface
|
|
;; (define-extern *board-air-mods* surface) ;; surface
|
|
;; (define-extern *board-jump-mods* surface) ;; surface
|
|
;; (define-extern *board-ride-jump-mods* surface) ;; surface
|
|
;; (define-extern *board-duck-jump-mods* object) ;; surface
|
|
;; (define-extern *board-spin-mods* object) ;; surface
|
|
;; (define-extern *board-spin-post-mods* object) ;; surface
|
|
;; (define-extern *board-flip-mods* object) ;; surface
|
|
;; (define-extern *board-wall-kick-mods* surface) ;; surface
|
|
;; (define-extern *board-halfpipe-mods* surface) ;; surface
|
|
;; (define-extern *board-turn-to-mods* surface) ;; surface
|
|
;; (define-extern *board-ride-mods* surface) ;; surface
|
|
;; (define-extern *collide-edge-board-halfpipe-spec* object) ;; collide-edge-spec
|
|
;; (define-extern target-board-green-eco-attack function)
|
|
;; (define-extern target-board-green-eco-use function)
|
|
;; (define-extern target-board-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern board-turn-around? function)
|
|
;; (define-extern target-board-setup function) ;; (function symbol none :behavior target)
|
|
;; (define-extern target-board-init function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-exit function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-falling-anim-trans function) ;; (function none :behavior target)
|
|
;; (define-extern board-on-ground? function) ;; (function symbol :behavior target)
|
|
;; (define-extern target-board-smack-surface? function) ;; (function symbol :behavior target)
|
|
;; (define-extern board-add-thrust function) ;; (function none :behavior target)
|
|
;; (define-extern segment-array-vector->index function) ;; (function (inline-array vector) int float float float)
|
|
;; (define-extern segment-array-index->vector function) ;; (function (inline-array vector) int float vector int)
|
|
;; (define-extern target-board-exit-check function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-trail function)
|
|
;; (define-extern target-board-effect function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-physics function) ;; (function vector none :behavior target)
|
|
;; (define-extern target-board-collision function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-joint-points function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-pre-move function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-real-post function) ;; (function none :behavior target)
|
|
;; (define-extern probe-test function) ;; (function control-info vector pat-surface symbol)
|
|
;; (define-extern target-board-compute-edge function) ;; (function time-frame :behavior target)
|
|
;; (define-extern board-ride-add-thrust function) ;; (function vector float none :behavior target)
|
|
;; (define-extern target-board-ride-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-center-anim function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-turn-anim function) ;; (function int none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; des-bush ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-desert-bbush-ring (task-manager)
|
|
((actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(current-ring int32 :offset-assert 244)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #xfc
|
|
:flag-assert #x22008000fc
|
|
(:methods
|
|
(task-manager-desert-bbush-ring-method-32 () none) ;; 32
|
|
(task-manager-desert-bbush-ring-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
resolution ;; 17
|
|
active ;; 15
|
|
fail ;; 18
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-bbush-ring-2 (task-manager-desert-bbush-ring)
|
|
()
|
|
:method-count-assert 34
|
|
:size-assert #xfc
|
|
:flag-assert #x22008000fc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-bbush-ring-3 (task-manager-desert-bbush-ring)
|
|
()
|
|
:method-count-assert 34
|
|
:size-assert #xfc
|
|
:flag-assert #x22008000fc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-bbush-ring-4 (task-manager-desert-bbush-ring)
|
|
()
|
|
:method-count-assert 34
|
|
:size-assert #xfc
|
|
:flag-assert #x22008000fc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-bbush-ring-5 (task-manager-desert-bbush-ring)
|
|
()
|
|
:method-count-assert 34
|
|
:size-assert #xfc
|
|
:flag-assert #x22008000fc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-bbush-ring-6 (task-manager-desert-bbush-ring)
|
|
()
|
|
:method-count-assert 34
|
|
:size-assert #xfc
|
|
:flag-assert #x22008000fc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-chase-ring (process-drawable)
|
|
((mat matrix :inline :offset-assert 208)
|
|
(taskman uint64 :offset-assert 272)
|
|
(turbo-handle uint64 :offset-assert 280)
|
|
(alt-actor basic :offset-assert 288)
|
|
(ring-radius float :offset-assert 292)
|
|
(minimap connection-minimap :offset-assert 296)
|
|
(is-final? basic :offset-assert 300)
|
|
(part-final basic :offset-assert 304)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x134
|
|
:flag-assert #x1800c00134
|
|
(:methods
|
|
(desert-chase-ring-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
dormant ;; 20
|
|
idle ;; 21
|
|
die ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spirit (process-drawable)
|
|
((part-subsampler basic :offset-assert 200)
|
|
(sound-id uint32 :offset-assert 204)
|
|
(sound-id-2 uint32 :offset-assert 208)
|
|
(play-pixie? basic :offset-assert 212)
|
|
(goal-part basic :offset-assert 216)
|
|
(draw-start-goal? basic :offset-assert 220)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xe0
|
|
:flag-assert #x17006000e0
|
|
(:state-methods
|
|
explode ;; 22
|
|
dormant ;; 21
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-spider-killed (hud-goal)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-egg-spider (task-manager)
|
|
((actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(goal-score uint32 :offset-assert 244)
|
|
(hud-score uint64 :offset-assert 252)
|
|
(hud-goal uint64 :offset-assert 260)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x110
|
|
:flag-assert #x2100900110
|
|
(:methods
|
|
(task-manager-bbush-egg-spider-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
resolution ;; 17
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-spirit-chase (task-manager)
|
|
((actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(path-pos float :offset-assert 244)
|
|
(trans vector :inline :offset-assert 252)
|
|
(touched basic :offset-assert 268)
|
|
(spirit uint64 :offset-assert 276)
|
|
(current-curve-distance float :offset-assert 284)
|
|
(current-curve-length float :offset-assert 288)
|
|
(min-spirit-vel float :offset-assert 292)
|
|
(current-spirit-vel float :offset-assert 296)
|
|
(high-spirit-vel float :offset-assert 300)
|
|
(fail-radius float :offset-assert 304)
|
|
(chase-distance float :offset-assert 308)
|
|
(start-offset-vel float :offset-assert 312)
|
|
(sound-id uint32 :offset-assert 316)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x144
|
|
:flag-assert #x2400d00144
|
|
(:methods
|
|
(task-manager-bbush-spirit-chase-method-32 () none) ;; 32
|
|
(task-manager-bbush-spirit-chase-method-33 () none) ;; 33
|
|
(task-manager-bbush-spirit-chase-method-34 () none) ;; 34
|
|
(task-manager-bbush-spirit-chase-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
resolution ;; 17
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-spirit-chase-2 (task-manager-bbush-spirit-chase)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x144
|
|
:flag-assert #x2400d00144
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-spirit-chase-3 (task-manager-bbush-spirit-chase)
|
|
()
|
|
:method-count-assert 36
|
|
:size-assert #x144
|
|
:flag-assert #x2400d00144
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bb-score-a-pickup (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bb-score-b-pickup (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bb-score-c-pickup (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype score-drop (process-drawable)
|
|
((src vector :inline :offset-assert 208)
|
|
(dst vector :inline :offset-assert 224)
|
|
(pickup-radius float :offset-assert 240)
|
|
(score uint32 :offset-assert 244)
|
|
(score-pickup-radius float :offset-assert 248)
|
|
(bb-score-type uint8 :offset-assert 252)
|
|
(traj trajectory :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x128
|
|
:flag-assert #x1700b00128
|
|
(:state-methods
|
|
dormant ;; 21
|
|
idle ;; 20
|
|
die ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-spirit-drop (task-manager)
|
|
((actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(path-pos float :offset-assert 244)
|
|
(trans vector :inline :offset-assert 252)
|
|
(touched basic :offset-assert 268)
|
|
(spirit uint64 :offset-assert 276)
|
|
(score-drop-handles UNKNOWN 64 :offset-assert 284)
|
|
(score-drop-num int32 :offset-assert 796)
|
|
(current-curve-distance float :offset-assert 800)
|
|
(current-curve-length float :offset-assert 804)
|
|
(goal-score uint32 :offset-assert 808)
|
|
(current-score uint32 :offset-assert 812)
|
|
(score-drop-activation-radius float :offset-assert 816)
|
|
(min-spirit-vel float :offset-assert 820)
|
|
(high-spirit-vel float :offset-assert 824)
|
|
(current-spirit-vel float :offset-assert 828)
|
|
(fail-radius float :offset-assert 832)
|
|
(hud-score uint64 :offset-assert 836)
|
|
(hud-goal uint64 :offset-assert 844)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x358
|
|
:flag-assert #x2702e00358
|
|
(:methods
|
|
(task-manager-bbush-spirit-drop-method-32 () none) ;; 32
|
|
(task-manager-bbush-spirit-drop-method-33 () none) ;; 33
|
|
(task-manager-bbush-spirit-drop-method-34 () none) ;; 34
|
|
(task-manager-bbush-spirit-drop-method-35 () none) ;; 35
|
|
(task-manager-bbush-spirit-drop-method-36 () none) ;; 36
|
|
(task-manager-bbush-spirit-drop-method-37 () none) ;; 37
|
|
(task-manager-bbush-spirit-drop-method-38 () none) ;; 38
|
|
)
|
|
(:state-methods
|
|
resolution ;; 17
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *tex-level-list* array)
|
|
;; (define-extern find-level-name function)
|
|
;; (define-extern set-ring-particle-texture function)
|
|
;; (define-extern *des-ring-times* array)
|
|
;; (define-extern *bb-fail* object)
|
|
;; (define-extern *bbush-ring-6-kg-squad-member-settings* object)
|
|
;; (define-extern desert-chase-ring-cleared? function)
|
|
;; (define-extern spirit-init-by-other function)
|
|
;; (define-extern bb-score-type->string function)
|
|
;; (define-extern score-drop-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; board-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern vector-vector-angle function) ;; (function vector vector float)
|
|
;; (define-extern target-board-anim-trans function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-spin-check function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-halfpipe-trans function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-resolve-points function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-ground-check function) ;; (function none :behavior target)
|
|
;; (define-extern target-board-halfpipe-check function) ;; (function collide-action :behavior target)
|
|
;; (define-extern target-board-jump-trans function) ;; (function none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; warp-gate ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype warp-gate (process-drawable)
|
|
((level-name uint32 :offset-assert 200) ;; guessed by decompiler
|
|
(on-notice pair :offset-assert 204) ;; guessed by decompiler
|
|
(on-activate pair :offset-assert 208) ;; guessed by decompiler
|
|
(on-close pair :offset-assert 212) ;; guessed by decompiler
|
|
(wait-for pair :offset-assert 216) ;; guessed by decompiler
|
|
(continue continue-point :offset-assert 220) ;; guessed by decompiler
|
|
(distance meters :offset-assert 224)
|
|
(anim-speed float :offset-assert 228)
|
|
(test-time uint64 :offset-assert 232) ;; time-frame
|
|
(center vector :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x100
|
|
:flag-assert #x1a00800100
|
|
;; field on-notice uses ~A with a signed load. field on-activate uses ~A with a signed load. field on-close uses ~A with a signed load.
|
|
(:methods
|
|
(warp-gate-method-23 () none) ;; 23 ;; (init-skel-and-collide (_type_) none 23)
|
|
(warp-gate-method-24 () none) ;; 24 ;; (setup-fields (_type_) none 24)
|
|
(warp-gate-method-25 () none) ;; 25 ;; (handle-notice (_type_) continue-point 25)
|
|
)
|
|
(:state-methods
|
|
hidden ;; 22, old: (hidden () _type_ :state 22)
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
use ;; 21, old: (use (continue-point) _type_ :state 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype air-train (warp-gate)
|
|
((part-exhaust-left sparticle-launch-control :offset-assert 256) ;; guessed by decompiler
|
|
(part-exhaust-right sparticle-launch-control :offset-assert 260) ;; guessed by decompiler
|
|
(part-dust sparticle-launch-control :offset-assert 264) ;; guessed by decompiler
|
|
(dust-y float :offset-assert 268)
|
|
(hover-sound sound-id :offset-assert 272) ;; guessed by decompiler
|
|
(base-pos vector :inline :offset-assert 288)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x130
|
|
:flag-assert #x1a00b00130
|
|
(:state-methods
|
|
idle ;; 20
|
|
use ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern warp-gate-init function) ;; (function entity-actor vector none :behavior warp-gate)
|
|
;; (define-extern *warp-jump-mods* surface) ;; surface
|
|
;; (define-extern *range-warp-dust-color* curve-color-fast)
|
|
;; (define-extern *range-warp-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-warp-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-warp-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-warp-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-warp-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-warp-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-warp-fma-dust-takeoff-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable-group ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; drawable-tree ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; roboguard ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype roboguard (nav-enemy)
|
|
((los los-control :inline :offset-assert 624)
|
|
(rotation-matrix matrix :inline :offset-assert 800)
|
|
(upper-rotation-matrix matrix :inline :offset-assert 864)
|
|
(fire-at-pos vector :inline :offset-assert 928)
|
|
(formation-position vector :inline :offset-assert 944)
|
|
(focus-formation-source vector :inline :offset-assert 960)
|
|
(me-to-focus-dir vector :inline :offset-assert 976)
|
|
(me-to-focus-angle float :offset-assert 992)
|
|
(flags uint16 :offset-assert 996)
|
|
(torso-aim-blend float :offset-assert 1000)
|
|
(torso-angle float :offset-assert 1004)
|
|
(torso-seek-speed float :offset-assert 1008)
|
|
(torso-to-focus-angle float :offset-assert 1012)
|
|
(last-torso-frame-num float :offset-assert 1016)
|
|
(stand-angle-threshold float :offset-assert 1020)
|
|
(arm-rot-mult UNKNOWN 2 :offset-assert 1024)
|
|
(arm-rot UNKNOWN 2 :offset-assert 1032)
|
|
(fire-time uint64 :offset-assert 1040)
|
|
(fire-count uint32 :offset-assert 1048)
|
|
(last-attack-time uint64 :offset-assert 1056)
|
|
(update-focus-pos basic :offset-assert 1064)
|
|
(formation-angle-sign float :offset-assert 1068)
|
|
(last-hit-points int32 :offset-assert 1072)
|
|
)
|
|
:method-count-assert 197
|
|
:size-assert #x434
|
|
:flag-assert #xc503c00434
|
|
(:methods
|
|
(roboguard-method-194 () none) ;; 194
|
|
(roboguard-method-195 () none) ;; 195
|
|
(roboguard-method-196 () none) ;; 196
|
|
)
|
|
(:state-methods
|
|
idle ;; 33
|
|
notice ;; 35
|
|
stare ;; 37
|
|
hostile-stand ;; 190
|
|
hostile ;; 38
|
|
knocked ;; 31
|
|
close-attack ;; 191
|
|
shoot-attack ;; 192
|
|
knocked-recover ;; 32
|
|
die ;; 40
|
|
explode ;; 193
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *roboguard-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *roboguard-explode-joints* array)
|
|
;; (define-extern *roboguard-debris-array-params* array)
|
|
;; (define-extern *fact-info-roboguard-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *roboguard-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern roboguard-turn-torso-post function)
|
|
;; (define-extern roboguard-turret-code function)
|
|
;; (define-extern *roboguard-formation-table* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prototype ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; main-collide ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern drawable-sphere-box-intersect? function) ;; (function drawable bounding-box4w symbol)
|
|
;; (define-extern instance-sphere-box-intersect? function) ;; (function drawable instance-tie bounding-box4w symbol)
|
|
;; (define-extern instance-tfragment-add-debug-sphere function) ;; (function drawable instance-tie symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mysql-nav-graph ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mysql-nav-node (structure)
|
|
((mysql-save-flag mysql-save-flag :offset-assert 0) ;; guessed by decompiler
|
|
(runtime-id uint32 :offset-assert 4)
|
|
(temp-edge-list (inline-array mysql-nav-edge) :offset-assert 8) ;; guessed by decompiler
|
|
(level-node-index int32 :offset-assert 12)
|
|
(cam-dist float :offset-assert 16)
|
|
(visible symbol :offset-assert 20) ;; guessed by decompiler
|
|
(nav_node_id uint32 :offset-assert 24)
|
|
(nav_graph_id uint32 :offset-assert 28)
|
|
(position vector :inline :offset-assert 32)
|
|
(level_name symbol :offset-assert 48) ;; guessed by decompiler
|
|
(angle float :offset-assert 52)
|
|
(radius float :offset-assert 56)
|
|
(nav_node_flag nav-node-flag :offset-assert 60) ;; guessed by decompiler
|
|
(nav_mesh_id uint32 :offset-assert 64)
|
|
(data_int_0 uint32 :offset-assert 68)
|
|
(data_int_1 uint32 :offset-assert 72)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x4c
|
|
:flag-assert #xb0000004c
|
|
(:methods
|
|
(mysql-nav-node-method-9 () none) ;; 9 ;; (exec-sql! (_type_) symbol 9)
|
|
(mysql-nav-node-method-10 () none) ;; 10 ;; (temp-edge-size (_type_) int 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mysql-nav-node-array (inline-array-class)
|
|
((data mysql-nav-node :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mysql-nav-edge (structure)
|
|
((mysql-save-flag mysql-save-flag :offset-assert 0) ;; guessed by decompiler
|
|
(runtime-id uint32 :offset-assert 4)
|
|
(runtime-node-id-1 int32 :offset-assert 8)
|
|
(runtime-node-id-2 int32 :offset-assert 12)
|
|
(temp-next-edge mysql-nav-edge :offset-assert 16)
|
|
(nav_edge_id uint32 :offset-assert 20)
|
|
(nav_graph_id uint32 :offset-assert 24)
|
|
(nav_node_id_1 uint32 :offset-assert 28)
|
|
(nav_node_id_2 uint32 :offset-assert 32)
|
|
(directionality nav-directionality :offset-assert 36) ;; guessed by decompiler
|
|
(speed_limit float :offset-assert 40)
|
|
(density float :offset-assert 44)
|
|
(traffic_edge_flag int32 :offset-assert 48)
|
|
(nav_clock_mask nav-clock-mask :offset-assert 52) ;; guessed by decompiler
|
|
(nav_clock_type nav-clock-type :offset-assert 56) ;; guessed by decompiler
|
|
(nav_territory_type uint32 :offset-assert 60)
|
|
(exclusive_data uint32 :offset-assert 64)
|
|
(width float :offset-assert 68)
|
|
(minimap_edge_flag int32 :offset-assert 72) ;; nav-minimap-edge-flag
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x4c
|
|
:flag-assert #xa0000004c
|
|
(:methods
|
|
(mysql-nav-edge-method-9 () none) ;; 9 ;; (exec-sql! (_type_) symbol 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mysql-nav-edge-array (inline-array-class)
|
|
((data mysql-nav-edge :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mysql-nav-visnode (structure)
|
|
((mysql-save-flag mysql-save-flag :offset-assert 0) ;; guessed by decompiler
|
|
(runtime-node-id int32 :offset-assert 4)
|
|
(runtime-edge-id int32 :offset-assert 8)
|
|
(nav_visnode_id uint32 :offset-assert 12)
|
|
(nav_graph_id uint32 :offset-assert 16)
|
|
(nav_node_id uint32 :offset-assert 20)
|
|
(nav_edge_id uint32 :offset-assert 24)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x1c
|
|
:flag-assert #xa0000001c
|
|
(:methods
|
|
(mysql-nav-visnode-method-9 () none) ;; 9 ;; (exec-sql! (_type_) symbol 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mysql-nav-visnode-array (inline-array-class)
|
|
((data mysql-nav-visnode :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mysql-nav-pov-conn (structure)
|
|
((runtime-node-id-1 int32 :offset-assert 0)
|
|
(runtime-node-id-2 int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mysql-nav-graph-level-info (structure)
|
|
((level symbol :offset-assert 0) ;; guessed by decompiler
|
|
(level-id uint32 :offset-assert 4)
|
|
(node-count int32 :offset-assert 8)
|
|
(branch-count int32 :offset-assert 12)
|
|
(to-link-count int32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mysql-nav-graph (basic)
|
|
((nav_graph_id uint32 :offset-assert 4)
|
|
(graph-type basic :offset-assert 8)
|
|
(node-array mysql-nav-node-array :offset-assert 12) ;; guessed by decompiler
|
|
(edge-array mysql-nav-edge-array :offset-assert 16) ;; guessed by decompiler
|
|
(visnode-array mysql-nav-visnode-array :offset-assert 20) ;; guessed by decompiler
|
|
(pov-conn-array uint32 :offset-assert 24)
|
|
(pov-conn-array-length int32 :offset-assert 28)
|
|
(level-info-array-length int32 :offset-assert 32)
|
|
(level-info-last-lookup int32 :offset-assert 36)
|
|
(level-info-array mysql-nav-graph-level-info 32 :offset-assert 40) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x428
|
|
:flag-assert #x1800000428
|
|
(:methods
|
|
;; (new (symbol type string) _type_ 0)
|
|
(mysql-nav-graph-method-9 () none) ;; 9 ;; (init-from-sql! (_type_ string string) symbol 9)
|
|
(mysql-nav-graph-method-10 () none) ;; 10 ;; (exec-sql! (_type_) symbol 10)
|
|
(mysql-nav-graph-method-11 () none) ;; 11 ;; (indexof-nav-node (_type_ int) int 11)
|
|
(mysql-nav-graph-method-12 () none) ;; 12 ;; (indexof-nav-edge (_type_ int) int 12)
|
|
(mysql-nav-graph-method-13 () none) ;; 13 ;; (alloc-new-node! (_type_) int 13)
|
|
(mysql-nav-graph-method-14 () none) ;; 14 ;; (alloc-new-edge! (_type_) int 14)
|
|
(mysql-nav-graph-method-15 () none) ;; 15 ;; (indexof-visnode (_type_ int int) int 15)
|
|
(mysql-nav-graph-method-16 () none) ;; 16 ;; (alloc-new-visnode! (_type_ int int) int 16)
|
|
(mysql-nav-graph-method-17 () none) ;; 17 ;; (mysql-nav-graph-method-17 (_type_) none 17)
|
|
(mysql-nav-graph-method-18 () none) ;; 18 ;; (lookup-level-info2 (_type_ mysql-nav-node symbol) mysql-nav-graph-level-info 18)
|
|
(mysql-nav-graph-method-19 () none) ;; 19 ;; (mysql-nav-graph-method-19 (_type_) none 19)
|
|
(mysql-nav-graph-method-20 () none) ;; 20 ;; (mysql-nav-graph-method-20 (_type_) none 20)
|
|
(mysql-nav-graph-method-21 () none) ;; 21
|
|
(mysql-nav-graph-method-22 () none) ;; 22
|
|
(mysql-nav-graph-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; foresta-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype water-anim-for (water-anim)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-anim-for-a (water-anim-for)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-anim-for-b (water-anim-for)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-anim-for-c (water-anim-for)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-anim-for-d (water-anim-for)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-anim-for-e (water-anim-for)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-anim-for-f (water-anim-for)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-log (process-drawable)
|
|
((shakers UNKNOWN 4 :offset-assert 208)
|
|
(last-ridden-time uint64 :offset-assert 464)
|
|
(water-anim basic :offset-assert 472)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x1dc
|
|
:flag-assert #x19016001dc
|
|
(:methods
|
|
(for-log-method-22 () none) ;; 22
|
|
(for-log-method-23 () none) ;; 23
|
|
(for-log-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-jump-pad (jump-pad)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x100
|
|
:flag-assert #x1e00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-pillar (process-drawable)
|
|
((extend-height meters :offset-assert 200)
|
|
(id int32 :offset-assert 204)
|
|
(sound-id uint32 :offset-assert 208)
|
|
(last-ride-time uint64 :offset-assert 216)
|
|
(ridden? basic :offset-assert 224)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xe4
|
|
:flag-assert #x19007000e4
|
|
(:methods
|
|
(for-pillar-method-23 () none) ;; 23
|
|
(for-pillar-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
rise ;; 21
|
|
complete ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-telescope (process-drawable)
|
|
((sound-id uint32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:methods
|
|
(for-telescope-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-tower (for-pillar)
|
|
((telescope uint64 :offset-assert 232)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xf0
|
|
:flag-assert #x19007000f0
|
|
(:state-methods
|
|
complete ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype shoulder-plates (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern ripple-for-water-anim-for ripple-wave-set)
|
|
;; (define-extern for-log-callback function)
|
|
;; (define-extern for-log-event-handler function)
|
|
;; (define-extern for-pillar-event-handler function)
|
|
;; (define-extern for-telescope-init-by-other function)
|
|
;; (define-extern shoulder-plates-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; video ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern set-video-mode function) ;; (function symbol none)
|
|
;; (define-extern get-video-mode function) ;; (function symbol)
|
|
;; (define-extern set-aspect-ratio function) ;; (function symbol none)
|
|
;; (define-extern get-aspect-ratio function) ;; (function symbol)
|
|
;; (define-extern set-progressive-scan function) ;; (function symbol none)
|
|
;; (define-extern get-progressive-scan function) ;; (function symbol)
|
|
;; (define-extern set-graphics-mode function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; main ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern set-letterbox-frames function) ;; (function time-frame none)
|
|
;; (define-extern letterbox function) ;; (function none)
|
|
;; (define-extern set-blackout-frames function) ;; (function time-frame none)
|
|
;; (define-extern blackout function) ;; (function none)
|
|
;; (define-extern add-blackout function)
|
|
;; (define-extern paused? function) ;; (function symbol)
|
|
;; (define-extern movie? function) ;; (function symbol)
|
|
;; (define-extern scene-select? function)
|
|
;; (define-extern demo? function) ;; (function symbol)
|
|
;; (define-extern kiosk? function)
|
|
;; (define-extern *last-master-mode* object) ;; symbol
|
|
;; (define-extern set-master-mode function) ;; (function symbol none)
|
|
;; (define-extern pause-allowed? function) ;; (function symbol)
|
|
;; (define-extern toggle-pause function) ;; (function int)
|
|
;; (define-extern *screen-filter* screen-filter) ;; screen-filter
|
|
;; (define-extern *cheat-temp* object) ;; (pointer int32)
|
|
;; (define-extern *master-exit* object) ;; symbol
|
|
;; (define-extern *progress-cheat* object) ;; symbol
|
|
;; (define-extern *first-boot* object) ;; symbol
|
|
;; (define-extern main-timeouts function)
|
|
;; (define-extern main-cheats function) ;; (function int)
|
|
;; (define-extern end-display function) ;; (function display none)
|
|
;; (define-extern display-loop-main function) ;; (function display none)
|
|
;; (define-extern display-loop function) ;; (function int :behavior process)
|
|
;; (define-extern on function) ;; (function symbol process)
|
|
;; (define-extern off function) ;; (function int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collide-cache ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collide-puls-work (structure)
|
|
((ignore-pat pat-surface :offset-assert 0) ;; guessed by decompiler
|
|
(bsphere sphere :inline :offset-assert 16)
|
|
(move-dist vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lsmi-work (structure)
|
|
((best-u float :offset-assert 0)
|
|
(orig-best-u float :offset-assert 4)
|
|
(action uint32 :offset-assert 8)
|
|
(cquery collide-query :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x22c
|
|
:flag-assert #x90000022c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern test-closest-pt-in-triangle function) ;; (function collide-cache symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; des-burning-bush ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bbush-menu-item (structure)
|
|
((text uint32 :offset-assert 0)
|
|
(node uint16 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bbush-menu (structure)
|
|
((title-text uint32 :offset-assert 0)
|
|
(req-text uint32 :offset-assert 4)
|
|
(req-check basic :offset-assert 8)
|
|
(item-count int8 :offset-assert 12)
|
|
(items UNKNOWN 10 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xb0
|
|
:flag-assert #x9000000b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-burning-bush (process-focusable)
|
|
((task basic :offset-assert 208)
|
|
(part-off basic :offset-assert 212)
|
|
(angle float :offset-assert 216)
|
|
(time float :offset-assert 220)
|
|
(rotmin float :offset-assert 224)
|
|
(rotmax float :offset-assert 228)
|
|
(bb-perm entity-perm :offset-assert 232)
|
|
(menu bbush-menu :offset-assert 236)
|
|
(menu-node basic :offset-assert 240)
|
|
(menu-exit? basic :offset-assert 244)
|
|
(menu-have-req? basic :offset-assert 248)
|
|
(message-id uint32 :offset-assert 252)
|
|
(required-vehicles uint64 :offset-assert 256)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x108
|
|
:flag-assert #x2700900108
|
|
(:methods
|
|
(des-burning-bush-method-32 () none) ;; 32
|
|
(des-burning-bush-method-33 () none) ;; 33
|
|
(des-burning-bush-method-34 () none) ;; 34
|
|
(des-burning-bush-method-35 () none) ;; 35
|
|
(des-burning-bush-method-36 () none) ;; 36
|
|
(des-burning-bush-method-37 () none) ;; 37
|
|
(des-burning-bush-method-38 () none) ;; 38
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
collect-gems ;; 31
|
|
talking ;; 29
|
|
menu ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype burning-bush-get-on-info (structure)
|
|
((trans vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(camera-trans vector :inline :offset-assert 32)
|
|
(camera-rot float 9 :offset-assert 48) ;; guessed by decompiler
|
|
(time float :offset-assert 84)
|
|
(fov float :offset-assert 88)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5c
|
|
:flag-assert #x90000005c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-bbush-get-to (task-manager)
|
|
((skill uint64 :offset-assert 240)
|
|
(update-fov? basic :offset-assert 248)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xfc
|
|
:flag-assert #x21008000fc
|
|
(:methods
|
|
(task-manager-desert-bbush-get-to-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wascity-burning-bush (des-burning-bush)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x108
|
|
:flag-assert #x2700900108
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-des-burning-bush (des-burning-bush)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x108
|
|
:flag-assert #x2700900108
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *bbush-menu* object)
|
|
;; (define-extern *burning-bush-get-on-info* array) ;; (array burning-bush-get-on-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; relocate ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; memory-usage ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; memory-usage-block is already defined!
|
|
|
|
;; (define-extern mem-size function) ;; (function basic symbol int int)
|
|
;; (define-extern *max-dma* object) ;; int
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tomb-baby-spider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tomb-baby-spider (nav-enemy)
|
|
()
|
|
:method-count-assert 192
|
|
:size-assert #x26c
|
|
:flag-assert #xc001f0026c
|
|
(:state-methods
|
|
active ;; 34
|
|
notice ;; 35
|
|
attack ;; 190
|
|
hostile ;; 38
|
|
attack-stop ;; 191
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dig-spider (tomb-baby-spider)
|
|
()
|
|
:method-count-assert 192
|
|
:size-assert #x26c
|
|
:flag-assert #xc001f0026c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *tomb-baby-fact-info-enemy* fact-info-enemy-defaults)
|
|
;; (define-extern *tomb-baby-spider-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-control-cfs-work (structure)
|
|
((in-dir vector :inline :offset-assert 0)
|
|
(right-dir vector :inline :offset-assert 16)
|
|
(best-dir vector 2 :offset-assert 32) ;; guessed by decompiler
|
|
(temp-dir vector 2 :offset-assert 64) ;; guessed by decompiler
|
|
(away-dir vector :inline :offset-assert 96)
|
|
(best-dir-angle degrees 2 :offset-assert 112) ;; guessed by decompiler
|
|
(ignore-mask uint64 :offset-assert 120)
|
|
(initial-ignore-mask uint64 :offset-assert 128)
|
|
(i-sphere int32 :offset-assert 136)
|
|
(i-first-sphere int32 :offset-assert 140)
|
|
(i-inside-sphere int32 :offset-assert 144)
|
|
(inside-sphere-dist float :offset-assert 148)
|
|
(sign float :offset-assert 152)
|
|
(travel-len float :offset-assert 156)
|
|
(dist2 float :offset-assert 160)
|
|
(inside-dist float :offset-assert 164)
|
|
(rand-angle float :offset-assert 168)
|
|
(dir-update basic :offset-assert 172)
|
|
(debug-offset vector :inline :offset-assert 176)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc0
|
|
:flag-assert #x9000000c0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *nav-triangle-test-count* object) ;; int
|
|
;; (define-extern *nav-last-triangle-test-count* object) ;; int
|
|
;; (define-extern debug-nav-validate-current-poly function) ;; (function nav-mesh nav-poly vector symbol)
|
|
;; (define-extern debug-report-nav-stats function) ;; (function none)
|
|
;; (define-extern get-nav-control function) ;; (function process-drawable nav-mesh none)
|
|
;; (define-extern add-nav-sphere function) ;; (function nav-control sphere int none)
|
|
;; (define-extern add-collide-shape-spheres function) ;; (function nav-control collide-shape sphere none)
|
|
;; (define-extern circle-tangent-directions function) ;; (function vector vector vector vector vector)
|
|
;; (define-extern circle-ray-intersection? function) ;; (function vector vector float vector symbol)
|
|
;; (define-extern find-closest-circle-ray-intersection function) ;; (function vector vector float int (inline-array vector) int int)
|
|
;; (define-extern compute-dir-parm function) ;; (function vector vector vector float)
|
|
;; (define-extern vector-rotate-y-sincos! function) ;; (function vector vector float float float)
|
|
;; (define-extern test-xz-point-on-line-segment? function) ;; (function vector vector vector float symbol)
|
|
;; (define-extern *null-nav-callback-info* object)
|
|
;; (define-extern *default-nav-callback-info* object)
|
|
;; (define-extern *physics-nav-callback-info* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mine-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mineb-light-state (structure)
|
|
((current float :offset-assert 0)
|
|
(target float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mineb-states (structure)
|
|
((lights UNKNOWN 3 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype minec-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(electricity electricity-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
;; (define-extern init-mood-minea function)
|
|
;; (define-extern update-mood-minea function)
|
|
;; (define-extern init-mood-mineb function)
|
|
;; (define-extern update-mood-mineb function)
|
|
;; (define-extern set-mineb-lights! function)
|
|
;; (define-extern init-mood-minec function)
|
|
;; (define-extern update-mood-minec function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; water-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-wsplash-color* curve-color-fast)
|
|
;; (define-extern *range-wsplash-alpha* curve2d-fast)
|
|
;; (define-extern *range-wsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-wsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-wsplash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-wsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-wsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-water-splash-curve-settings* object)
|
|
;; (define-extern *range-splash-color* curve-color-fast)
|
|
;; (define-extern *range-splash-alpha* curve2d-fast)
|
|
;; (define-extern *range-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-splash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-water-splash-center-curve-settings* object)
|
|
;; (define-extern *curve-wsplash-small-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-wsplash-small-scale-y* curve2d-fast)
|
|
;; (define-extern *part-water-splash-small-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; water ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern check-water-level-drop function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern check-water-level-drop-and-die function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern check-water-level-drop-and-die-motion function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern check-water-level-above-and-die function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern check-water-level-drop-motion function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern *water-simple-alpha-curve-in* object)
|
|
;; (define-extern *growing-curve* object)
|
|
;; (define-extern *water-simple-alpha-curve-fade-out* object)
|
|
;; (define-extern *color-curve-tan-brown* object)
|
|
;; (define-extern *water-wake-trail* object)
|
|
;; (define-extern part-water-splash-callback function) ;; (function part-tracker none)
|
|
;; (define-extern splash-spawn function) ;; (function float vector int none)
|
|
;; (define-extern rings-water-spawn function) ;; (function float vector vector float float none)
|
|
;; (define-extern water-info<-region function) ;; (function water-info drawable-region-prim collide-shape collide-action water-info)
|
|
;; (define-extern find-water-1 function)
|
|
;; (define-extern find-water-2 function)
|
|
;; (define-extern find-water-with-spheres function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gem-pool ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern get-gem-pool-size function)
|
|
;; (define-extern compare-gems function)
|
|
;; (define-extern gems-available? function)
|
|
;; (define-extern notify-gem-pickup function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-mirage ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-mirage (wcar-snake-base)
|
|
()
|
|
:method-count-assert 203
|
|
:size-assert #xd60
|
|
:flag-assert #xcb0ce00d60
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; task-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype resetter-control (basic)
|
|
((process uint64 :offset-assert 8)
|
|
(handle-init-hack basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x10
|
|
:flag-assert #xd00000010
|
|
(:methods
|
|
(resetter-control-method-9 () none) ;; 9
|
|
(resetter-control-method-10 () none) ;; 10
|
|
(resetter-control-method-11 () none) ;; 11
|
|
(resetter-control-method-12 () none) ;; 12
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype resetter (process)
|
|
((params resetter-params :inline :offset-assert 128)
|
|
(message uint8 :offset-assert 128)
|
|
(flags uint16 :offset-assert 130)
|
|
(reset-delay uint32 :offset-assert 164)
|
|
(task uint8 :offset-assert 168)
|
|
(text-message uint32 :offset-assert 172)
|
|
(retry resetter-spec :inline :offset-assert 148)
|
|
(retry-continue basic :offset-assert 148)
|
|
(retry-node uint16 :offset-assert 152)
|
|
(retry-reset-mode basic :offset-assert 156)
|
|
(fail resetter-spec :inline :offset-assert 132)
|
|
(fail-continue basic :offset-assert 132)
|
|
(fail-node uint16 :offset-assert 136)
|
|
(fail-reset-mode basic :offset-assert 140)
|
|
(resetter-id uint32 :offset-assert 176)
|
|
(grabbed-player? basic :offset-assert 180)
|
|
(grabbed-time uint64 :offset-assert 184)
|
|
(dead-player? basic :offset-assert 192)
|
|
(retry? basic :offset-assert 196)
|
|
(message-id uint32 :offset-assert 200)
|
|
(stinger uint32 :offset-assert 204)
|
|
(start-time uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #xd8
|
|
:flag-assert #x11006000d8
|
|
(:methods
|
|
(resetter-method-16 () none) ;; 16
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
resetting ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *resetter-control* resetter-control)
|
|
;; (define-extern game-task-node->string function) ;; (function game-task-node string)
|
|
;; (define-extern reset-city-squad-control function)
|
|
;; (define-extern city-task-faction-commands function)
|
|
;; (define-extern evaluate-faction-commands function)
|
|
;; (define-extern update-task-masks function) ;; (function symbol int)
|
|
;; (define-extern play-clean function) ;; (function symbol int)
|
|
;; (define-extern play-task function) ;; (function game-task symbol symbol string)
|
|
;; (define-extern restart-mission function) ;; (function int)
|
|
;; (define-extern fail-mission function) ;; type
|
|
;; (define-extern task-node-by-name function) ;; (function string game-task-node-info)
|
|
;; (define-extern task-node-index-by-name function)
|
|
;; (define-extern task-resolution-close! function) ;; (function game-task symbol)
|
|
;; (define-extern task-close! function) ;; (function string symbol)
|
|
;; (define-extern task-closed? function) ;; (function string symbol)
|
|
;; (define-extern open-task-nodes function) ;; (function (array game-task-node-info) (array game-task-node-info))
|
|
;; (define-extern task-node-closed? function) ;; (function game-task-node symbol)
|
|
;; (define-extern task-node-close! function) ;; (function game-task-node int)
|
|
;; (define-extern task-open? function)
|
|
;; (define-extern task-node-open? function) ;; (function game-task-node symbol)
|
|
;; (define-extern task-node-open! function) ;; (function game-task-node int)
|
|
;; (define-extern task-node-close-upwards function)
|
|
;; (define-extern task-node-reset function) ;; (function symbol int)
|
|
;; (define-extern task-node-dump function) ;; (function symbol symbol)
|
|
;; (define-extern resetter-init-by-other function)
|
|
;; (define-extern task-manager-init-by-other function) ;; (function game-task-node-info symbol object :behavior task-manager)
|
|
;; (define-extern task-manager-event-handler function) ;; (function process int symbol event-message-block object :behavior task-manager)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sew-laser-guard ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gun-turret-params (structure)
|
|
((normal-sg skeleton-group :offset-assert 0) ;; guessed by decompiler
|
|
(explode-sg skeleton-group :offset-assert 4) ;; guessed by decompiler
|
|
(enemy-info enemy-info :offset-assert 8) ;; guessed by decompiler
|
|
(idle-anim int32 :offset-assert 12)
|
|
(shoot-anim int32 :offset-assert 16)
|
|
(track-joint int32 :offset-assert 20)
|
|
(barrel-joint int32 :offset-assert 24)
|
|
(gun-joint int32 :offset-assert 28)
|
|
(hole-joints int32 8 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-laser-guard (enemy)
|
|
((params gun-turret-params :offset-assert 552)
|
|
(aim-pos vector :inline :offset-assert 560)
|
|
(smoke-part basic :offset-assert 576)
|
|
(casing-part basic :offset-assert 580)
|
|
(sync-orient sync-linear :inline :offset-assert 584)
|
|
(start-orient quaternion :inline :offset-assert 608)
|
|
(end-orient quaternion :inline :offset-assert 624)
|
|
(last-play-sweep-dir-positive? basic :offset-assert 640)
|
|
(last-play-sweep-sync float :offset-assert 644)
|
|
(sound-hum uint32 :offset-assert 648)
|
|
(sound-scorch uint32 :offset-assert 652)
|
|
)
|
|
:method-count-assert 157
|
|
:size-assert #x290
|
|
:flag-assert #x9d02100290
|
|
(:methods
|
|
(sew-laser-guard-method-155 () none) ;; 155
|
|
(sew-laser-guard-method-156 () none) ;; 156
|
|
)
|
|
(:state-methods
|
|
hostile ;; 38
|
|
hit ;; 30
|
|
stare ;; 37
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-laser-shot (projectile)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x200
|
|
:flag-assert #x2901800200
|
|
(:state-methods
|
|
dissipate ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sew-laser-shot-move function)
|
|
;; (define-extern *sew-laser-guard-enemy-info* enemy-info)
|
|
;; (define-extern fire-laser! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; scene ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype scene-stage (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype subtitle-work (structure)
|
|
((draw-tmpl dma-gif-packet :inline :offset-assert 0)
|
|
(color0 vector4w :inline :offset-assert 32)
|
|
(color1 vector4w :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
;; (define-extern scene-decode-continue function) ;; (function basic continue-point)
|
|
;; (define-extern scene-lookup function) ;; (function basic scene)
|
|
;; (define-extern *subtitle-work* object) ;; subtitle-work
|
|
;; (define-extern draw-subtitle-image function) ;; (function subtitle-image font-context none)
|
|
;; (define-extern process-drawable-draw-subtitles function) ;; (function none :behavior process-drawable)
|
|
;; (define-extern scene-player-init function) ;; (function object symbol string none :behavior scene-player)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; crates ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype crate-bank (basic)
|
|
((COLLIDE_YOFF float :offset-assert 4)
|
|
(COLLIDE_RADIUS float :offset-assert 8)
|
|
(DARKECO_EXPLODE_RADIUS float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype crate (process-focusable)
|
|
((smush smush-control :inline :offset-assert 208)
|
|
(base vector :inline :offset-assert 240)
|
|
(look symbol :offset-assert 256) ;; guessed by decompiler
|
|
(defense symbol :offset-assert 260) ;; guessed by decompiler
|
|
(incoming-attack-id uint32 :offset-assert 264)
|
|
(target uint64 :offset-assert 272) ;; handle
|
|
(child-count int32 :offset-assert 280)
|
|
(victory-anim spool-anim :offset-assert 284) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x120
|
|
:flag-assert #x2b00a00120
|
|
(:methods
|
|
(crate-method-36 () none) ;; 36 ;; (skel-init! (_type_) none 36)
|
|
(crate-method-37 () none) ;; 37 ;; (params-set! (_type_ symbol symbol) none 37)
|
|
(crate-method-38 () none) ;; 38 ;; (crate-method-38 (_type_) none 38)
|
|
(crate-method-39 () none) ;; 39 ;; (smush-update! (_type_) none 39)
|
|
(crate-method-40 () none) ;; 40 ;; (crate-method-40 (_type_) symbol 40)
|
|
(crate-method-41 () none) ;; 41
|
|
(crate-method-42 () none) ;; 42
|
|
)
|
|
(:state-methods
|
|
hide ;; 28, old: (idle () _type_ :state 28)
|
|
idle ;; 29, old: (die (symbol int) _type_ :state 29)
|
|
carry ;; 34, old: (fall () _type_ :state 34)
|
|
fall ;; 35, old: (crate-init! (_type_ entity-actor) none 35)
|
|
bounce-on ;; 32, old: (notice-blue (handle) _type_ :state 32)
|
|
notice-blue ;; 33, old: (carry () _type_ :state 33)
|
|
die ;; 30, old: (special-contents-die () _type_ :state 30)
|
|
special-contents-die ;; 31, old: (bounce-on () _type_ :state 31)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pickup-spawner (crate)
|
|
((blocker entity-actor :offset-assert 288) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x124
|
|
:flag-assert #x2b00b00124
|
|
(:state-methods
|
|
idle ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype urn-a (crate)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x120
|
|
:flag-assert #x2b00a00120
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype urn-b (crate)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x120
|
|
:flag-assert #x2b00a00120
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype urn-c (crate)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x120
|
|
:flag-assert #x2b00a00120
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *CRATE-bank* crate-bank) ;; crate-bank
|
|
;; (define-extern collectable-count function)
|
|
;; (define-extern crate-post function) ;; (function none :behavior crate)
|
|
;; (define-extern crate-standard-event-handler function) ;; (function process int symbol event-message-block object :behavior crate)
|
|
;; (define-extern crate-init-by-other function) ;; (function entity vector symbol fact-info-crate none :behavior crate)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sew-whirlpool ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sew-whirlpool (process-drawable)
|
|
((spool-sound-id uint32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ocean-transition ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; part-tester ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype part-tester (process)
|
|
((root trsqv :offset-assert 128) ;; guessed by decompiler
|
|
(part sparticle-launch-control :offset-assert 132) ;; guessed by decompiler
|
|
(old-group sparticle-launch-group :offset-assert 136) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x8c
|
|
:flag-assert #xe0010008c
|
|
(:states
|
|
part-tester-idle ;; associated process guessed by decompiler, old: (state part-tester)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *part-tester-name* object) ;; string
|
|
;; (define-extern part-tester-init-by-other function) ;; (function vector none :behavior process-drawable)
|
|
;; (define-extern *debug-part-dead-pool* object) ;; dead-pool
|
|
;; (define-extern start-part function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ftank-projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ftank-shot (projectile)
|
|
((hit-actor? basic :offset-assert 512)
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern ftank-shot-move function)
|
|
;; (define-extern spawn-ftank-projectile function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; manipulator ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype manipulator (structure)
|
|
((action uint32 :offset-assert 0)
|
|
(mode uint32 :offset-assert 4)
|
|
(dragging? basic :offset-assert 8)
|
|
(position vector :inline :offset-assert 16)
|
|
(speed vector :inline :offset-assert 32)
|
|
(drag-ref-position vector :inline :offset-assert 48)
|
|
(mouse-ref-position vector :inline :offset-assert 64)
|
|
(mat matrix :inline :offset-assert 80)
|
|
(rotate-ref int32 :offset-assert 144)
|
|
(angles euler-angles :inline :offset-assert 160)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #xb0
|
|
:flag-assert #xf000000b0
|
|
(:methods
|
|
(manipulator-method-9 () none) ;; 9
|
|
(manipulator-method-10 () none) ;; 10
|
|
(manipulator-method-11 () none) ;; 11
|
|
(manipulator-method-12 () none) ;; 12
|
|
(manipulator-method-13 () none) ;; 13
|
|
(manipulator-method-14 () none) ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern draw-axis function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fac-tower ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fac-gun-tower-base (process-focusable)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #xd0
|
|
:flag-assert #x1e005000d0
|
|
(:state-methods
|
|
explode ;; 29
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-tower-base (fac-gun-tower-base)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #xd0
|
|
:flag-assert #x1e005000d0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fac-tower-impact-pos* object)
|
|
;; (define-extern *fac-gun-tower-break-anim-idx* object)
|
|
;; (define-extern fac-gun-tower-base-broken-init-by-other function)
|
|
;; (define-extern fac-gun-tower-break-init-by-other function)
|
|
;; (define-extern start-destroyed-fac-gun-tower-base function)
|
|
;; (define-extern start-destroyed-fac-gun-tower function)
|
|
;; (define-extern fac-gun-tower-standard-event-handler function)
|
|
;; (define-extern fac-deg-delta function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; editable-player ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cleanup-selection function) ;; (function editable-array none)
|
|
;; (define-extern insert-box function) ;; (function editable-array vector none)
|
|
;; (define-extern insert-wall function)
|
|
;; (define-extern update-manipulator-position function)
|
|
;; (define-extern execute-select function) ;; (function editable-array editable-command mouse-info symbol)
|
|
;; (define-extern execute-mouse-move function) ;; (function editable-array editable-command mouse-info symbol)
|
|
;; (define-extern execute-move function) ;; (function editable-array editable-command mouse-info symbol)
|
|
;; (define-extern get-light-value function)
|
|
;; (define-extern set-light-value function)
|
|
;; (define-extern keybd-set-time-of-day! function)
|
|
;; (define-extern editable-player-init function) ;; (function symbol none :behavior editable-player)
|
|
;; (define-extern set-editable-name function)
|
|
;; (define-extern select-editable-by-name function)
|
|
;; (define-extern *editable-menu-context* object) ;; debug-menu-context
|
|
;; (define-extern editable-menu-command function) ;; (function int none)
|
|
;; (define-extern editable-menu-command-no-close function) ;; (function int none)
|
|
;; (define-extern dm-region-tree-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-editable-flag-pick-func function) ;; (function editable-flag debug-menu-msg symbol)
|
|
;; (define-extern dm-editable-filter0-pick-func function) ;; (function editable-filter debug-menu-msg symbol)
|
|
;; (define-extern dm-editable-filter1-pick-func function) ;; (function editable-filter debug-menu-msg symbol)
|
|
;; (define-extern dm-editable-light-float-func function) ;; (function int debug-menu-msg float float float)
|
|
;; (define-extern dm-cam-externalize2 function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-editable-boolean-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern editable-menu-context-make-menus function) ;; (function debug-menu-context debug-menu-context)
|
|
;; (define-extern insert-sample-camera function) ;; (function symbol none)
|
|
;; (define-extern *debug-hook* object) ;; pair
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sewer-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sew-curved-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-floating-plat (elevator)
|
|
()
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-cam-sequencer (process)
|
|
((activate-script basic :offset-assert 132)
|
|
(enter-script basic :offset-assert 136)
|
|
(exit-script basic :offset-assert 140)
|
|
(timeout uint64 :offset-assert 144)
|
|
(offset uint64 :offset-assert 152)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #xa0
|
|
:flag-assert #xf002000a0
|
|
;; field activate-script uses ~A with a signed load. field enter-script uses ~A with a signed load. field exit-script uses ~A with a signed load.
|
|
(:state-methods
|
|
active ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-floor-switch (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:state-methods
|
|
idle-up ;; 20
|
|
going-down ;; 21
|
|
idle-down ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-jump-pad (jump-pad)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x100
|
|
:flag-assert #x1e00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-fan (enemy)
|
|
((activate-distance float :offset-assert 552)
|
|
(path-pos float :offset-assert 556)
|
|
(sweep-dir int8 :offset-assert 560)
|
|
(travel-dir int8 :offset-assert 561)
|
|
(float-quat quaternion :inline :offset-assert 576)
|
|
(base-trans-y float :offset-assert 592)
|
|
(base-quat quaternion :inline :offset-assert 608)
|
|
(dest-quat quaternion :inline :offset-assert 624)
|
|
(fan-rot float :offset-assert 640)
|
|
(fan-rot-vel float :offset-assert 644)
|
|
(hostile-part basic :offset-assert 648)
|
|
(gust-part basic :offset-assert 652)
|
|
(sound-fan-loop-id uint32 :offset-assert 656)
|
|
)
|
|
:method-count-assert 155
|
|
:size-assert #x294
|
|
:flag-assert #x9b02200294
|
|
(:state-methods
|
|
idle ;; 33
|
|
notice ;; 35
|
|
active ;; 34
|
|
hostile ;; 38
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-elevator (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:methods
|
|
(sew-elevator-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-gate (process-drawable)
|
|
((play-time uint64 :offset-assert 200)
|
|
(sound-played1 basic :offset-assert 208)
|
|
(sound-played2 basic :offset-assert 212)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd8
|
|
:flag-assert #x17006000d8
|
|
(:state-methods
|
|
idle ;; 20
|
|
open ;; 21
|
|
opened ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-wall-switch (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
(minimap connection-minimap :offset-assert 204)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd4
|
|
:flag-assert #x17006000d4
|
|
(:state-methods
|
|
idle ;; 20
|
|
open ;; 21
|
|
opened ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-fence-gate (process-drawable)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
(:state-methods
|
|
closed ;; 20
|
|
open ;; 21
|
|
opening ;; 22
|
|
closing ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-vent (process-drawable)
|
|
((sync sync-linear :inline :offset-assert 200)
|
|
(attack-id int32 :offset-assert 216)
|
|
(last-sync-val float :offset-assert 220)
|
|
(vent-sound uint32 :offset-assert 224)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xe4
|
|
:flag-assert #x15007000e4
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-power-switch (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
turned-off ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-gas-step (base-plat)
|
|
((sound-id uint32 :offset-assert 272)
|
|
(sync sync-linear :inline :offset-assert 280)
|
|
(last-sync-val float :offset-assert 296)
|
|
(gas-time uint64 :offset-assert 304)
|
|
(attack-id int32 :offset-assert 312)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x13c
|
|
:flag-assert #x2400c0013c
|
|
(:state-methods
|
|
idle ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sewer-login function)
|
|
;; (define-extern sewer-logout function)
|
|
;; (define-extern sewb-activate function)
|
|
;; (define-extern sewc-activate function)
|
|
;; (define-extern sewg-activate function)
|
|
;; (define-extern sewl-activate function)
|
|
;; (define-extern sewo-activate function)
|
|
;; (define-extern sewj-activate function)
|
|
;; (define-extern sew-cam-sequencer-init-by-other function)
|
|
;; (define-extern sew-cam-eval-script function)
|
|
;; (define-extern *sew-fan-enemy-info* enemy-info)
|
|
;; (define-extern *sew-fan-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern update-surface-float function)
|
|
;; (define-extern update-idle function)
|
|
;; (define-extern update-hostile function)
|
|
;; (define-extern sew-fan-joint-fan function)
|
|
;; (define-extern sew-fan-joint-floor function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-mesh-editor ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype triangulation-vert (structure)
|
|
((index uint32 :offset-assert 0)
|
|
(ear? basic :offset-assert 4)
|
|
(score float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern snap-level-navmesh function)
|
|
;; (define-extern mouse-intersect-triangle function)
|
|
;; (define-extern *clean-vertex-array* object)
|
|
;; (define-extern *clean-index-array* object)
|
|
;; (define-extern poly-flag-to-string function)
|
|
;; (define-extern point-in-cone function)
|
|
;; (define-extern segment-in-cone function)
|
|
;; (define-extern point-in-triangle function)
|
|
;; (define-extern segments-intersect function)
|
|
;; (define-extern is-diagonal function)
|
|
;; (define-extern *verts-buf-1* object)
|
|
;; (define-extern *verts-buf-2* object)
|
|
;; (define-extern draw-square-point function)
|
|
;; (define-extern get-level-id function)
|
|
;; (define-extern nav-mesh-editor-new function)
|
|
;; (define-extern nav-delete function)
|
|
;; (define-extern nav-mesh-editor-translate function)
|
|
;; (define-extern nav-mesh-editor-rotate-y function)
|
|
;; (define-extern nav-mesh-editor-load function)
|
|
;; (define-extern nav-mesh-editor-set-level function)
|
|
;; (define-extern nav-set-lev function)
|
|
;; (define-extern nav-set-flag function)
|
|
;; (define-extern nav-mesh-editor-init function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctymark-obs-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype market-object (crate)
|
|
((sound-explode basic :offset-assert 288)
|
|
(part-explode basic :offset-assert 292)
|
|
(explode-matrix matrix :inline :offset-assert 304)
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
(:state-methods
|
|
idle ;; 29
|
|
die ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype market-basket-a (market-object)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype market-basket-b (market-object)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype market-crate (market-object)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype market-sack-a (market-object)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype market-sack-b (market-object)
|
|
()
|
|
:method-count-assert 43
|
|
:size-assert #x170
|
|
:flag-assert #x2b00f00170
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fruit-stand (process-focusable)
|
|
((incoming-attack-id uint32 :offset-assert 208)
|
|
(hack-counter uint32 :offset-assert 212)
|
|
(count-sparts uint32 :offset-assert 216)
|
|
(first-sparts uint32 :offset-assert 220)
|
|
(num-sparts uint32 :offset-assert 224)
|
|
(sparts-index uint32 4 :offset-assert 228) ;; guessed by decompiler
|
|
(sparts-pos vector 4 :offset-assert 256) ;; guessed by decompiler
|
|
(parts-alive? basic :offset-assert 320)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #x144
|
|
:flag-assert #x1f00d00144
|
|
(:methods
|
|
(fruit-stand-method-28 () none) ;; 28 ;; (fruit-stand-method-28 (_type_) none 28)
|
|
(fruit-stand-method-29 () none) ;; 29 ;; (fruit-stand-method-29 (_type_) none 29)
|
|
(fruit-stand-method-30 () none) ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; pilot-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern target-pilot-bike-anim-loop function) ;; (function none :behavior target)
|
|
;; (define-extern target-pilot-car-anim-loop function) ;; (function none :behavior target)
|
|
;; (define-extern target-pilot-wcar-anim-loop function)
|
|
;; (define-extern target-pilot-glider-anim-loop function)
|
|
;; (define-extern target-daxter-pilot-car-anim-loop function) ;; (function none :behavior target)
|
|
;; (define-extern target-pilot-trans function) ;; (function none :behavior target)
|
|
;; (define-extern target-pilot-signal-ready function) ;; (function object :behavior target)
|
|
;; (define-extern *pilot-get-on-mods* object) ;; surface
|
|
;; (define-extern *pilot-get-off-mods* object) ;; surface
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; default-menu ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *debug-menu-context* object) ;; debug-menu-context
|
|
;; (define-extern *dm-cam-mode-interpolation* object) ;; int
|
|
;; (define-extern dm-cam-mode-func function) ;; (function (state camera-slave) debug-menu-msg object)
|
|
;; (define-extern dm-cam-mode-default function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-cam-settings-default function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-cam-settings-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-cam-settings-func-int function) ;; (function int debug-menu-msg int int int)
|
|
;; (define-extern dm-cam-externalize function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-cam-setting-float function) ;; (function float debug-menu-msg float float float)
|
|
;; (define-extern dm-cam-render-float function) ;; (function int debug-menu-msg float float float)
|
|
;; (define-extern dm-subdiv-float function) ;; (function symbol debug-menu-msg float float float)
|
|
;; (define-extern dm-subdiv-int function) ;; (function symbol debug-menu-msg int int int)
|
|
;; (define-extern dm-select-race-path function) ;; (function object debug-menu-msg int int)
|
|
;; (define-extern dm-setting-language function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-setting-subtitle-language function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-setting-audio-language function)
|
|
;; (define-extern dm-setting-stereo-mode function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-current-continue function) ;; (function string debug-menu-msg symbol)
|
|
;; (define-extern dm-subdiv-draw-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-scissor-subdiv-draw-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-foreground-subdiv-draw-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-on-func function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-outline-func function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-back-face-func function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-normals-func function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-ghost-hidden-func function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-track-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-show-only-toggle-func function) ;; (function uint debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-show-only-set-func function) ;; (function uint debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-cspec-toggle function) ;; (function uint debug-menu-msg symbol)
|
|
;; (define-extern dm-col-rend-size function) ;; (function object debug-menu-msg float float)
|
|
;; (define-extern dm-col-rend-cam-dist function) ;; (function object debug-menu-msg float float)
|
|
;; (define-extern dm-ocean-height-func function) ;; (function ocean-height-hack debug-menu-msg symbol)
|
|
;; (define-extern dm-ocean-subdiv-draw-func function) ;; (function object debug-menu-msg symbol)
|
|
;; (define-extern dm-time-of-day-func function) ;; (function dm-time-of-day-setting debug-menu-msg symbol)
|
|
;; (define-extern dm-time-of-day-func2 function) ;; (function symbol debug-menu-msg object)
|
|
;; (define-extern dm-time-of-day-palette-func function) ;; (function dm-time-of-day-palette-settings debug-menu-msg symbol)
|
|
;; (define-extern dm-boolean-toggle-pick-func function) ;; (function symbol debug-menu-msg object)
|
|
;; (define-extern dm-time-of-day-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-stats-memory-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-actor-marks-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-debug-actor-lod-dist function)
|
|
;; (define-extern dm-select-race-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-compact-actor-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-actor-vis-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-game-mode-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-game-feature-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-game-vehicle-toggle-pick-func function)
|
|
;; (define-extern dm-game-secret-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern display-scene-control-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern display-scene-control-set-pick-func function) ;; (function scene-controls debug-menu-msg symbol)
|
|
;; (define-extern display-bot-marks-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern display-bot-marks-set-pick-func function) ;; (function bot-marks-controls debug-menu-msg symbol)
|
|
;; (define-extern display-race-marks-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern display-race-marks-set-pick-func function) ;; (function race-marks-controls debug-menu-msg symbol)
|
|
;; (define-extern dm-vu1-user-toggle-pick-func function) ;; (function vu1-renderer-mask debug-menu-msg symbol)
|
|
;; (define-extern dm-vu1-user-all-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-vu1-user-none-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-texture-user-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-texture-user-set-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-strip-lines-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-strip-lines-set-pick-func function) ;; (function strip-lines-controls debug-menu-msg symbol)
|
|
;; (define-extern dm-edit-instance-toggle-pick-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern all-texture-tweak-adjust function) ;; (function texture-page-dir float none)
|
|
;; (define-extern dm-float-field-tie-rvanish-func function) ;; (function symbol debug-menu-msg float float float)
|
|
;; (define-extern dm-float-field-tie-vanish-far-func function) ;; (function symbol debug-menu-msg float float float)
|
|
;; (define-extern dm-bug-report-output-pick-func function) ;; (function symbol debug-menu-msg symbol)
|
|
;; (define-extern dm-bug-report-report-pick-func function) ;; (function symbol debug-menu-msg none)
|
|
;; (define-extern debug-menu-node<? function) ;; (function debug-menu-node debug-menu-node symbol)
|
|
;; (define-extern dm-shader-pick-func function) ;; (function texture-id debug-menu-msg symbol)
|
|
;; (define-extern *shader-pick-menu* object) ;; debug-menu
|
|
;; (define-extern build-shader-list function) ;; (function none)
|
|
;; (define-extern dm-instance-pick-func function) ;; (function string debug-menu-msg basic)
|
|
;; (define-extern dm-enable-instance-func function) ;; (function string debug-menu-msg symbol)
|
|
;; (define-extern *instance-shrub-menu* object) ;; debug-menu
|
|
;; (define-extern *instance-tie-menu* object) ;; debug-menu
|
|
;; (define-extern *enable-instance-shrub-menu* object) ;; debug-menu
|
|
;; (define-extern *enable-instance-tie-menu* object) ;; debug-menu
|
|
;; (define-extern build-instance-list function) ;; (function object none)
|
|
;; (define-extern dm-scene-load-pick-func function) ;; (function pair debug-menu-msg symbol)
|
|
;; (define-extern debug-create-cam-restore function) ;; (function none)
|
|
;; (define-extern debug-menu-make-camera-mode-menu function) ;; (function debug-menu debug-menu debug-menu-node)
|
|
;; (define-extern debug-menu-make-camera-menu function) ;; (function debug-menu-context debug-menu-item-submenu)
|
|
;; (define-extern debug-menu-make-shader-menu function) ;; (function debug-menu-context debug-menu-item-submenu)
|
|
;; (define-extern debug-menu-make-instance-menu function) ;; (function debug-menu-context debug-menu-item-submenu)
|
|
;; (define-extern dm-task-menu-pick-func function) ;; (function game-task debug-menu-msg symbol)
|
|
;; (define-extern debug-menu-make-continue-sub-menu function) ;; (function game-info symbol pair)
|
|
;; (define-extern debug-menu-make-task-sub-menu function) ;; (function symbol pair)
|
|
;; (define-extern debug-menu-make-task-menu function) ;; (function debug-menu-context debug-menu-item-submenu)
|
|
;; (define-extern dm-play-task-with-continue function) ;; (function game-task string none)
|
|
;; (define-extern dm-play-task function) ;; (function game-task none)
|
|
;; (define-extern dm-play-race function) ;; (function race-selection symbol none)
|
|
;; (define-extern debug-menu-make-play-menu function) ;; (function debug-menu-context debug-menu-node)
|
|
;; (define-extern dm-anim-tester-flag-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-anim-tester-func function) ;; (function int debug-menu-msg symbol)
|
|
;; (define-extern dm-pilot-mode function) ;; (function object none)
|
|
;; (define-extern stop-watch-display function) ;; (function object object symbol)
|
|
;; (define-extern debug-menu-context-make-default-menus function) ;; (function debug-menu-context debug-menu-context)
|
|
;; (define-extern *popup-menu-context* object) ;; debug-menu-context
|
|
;; (define-extern popup-menu-context-make-default-menus function) ;; (function debug-menu-context debug-menu-context)
|
|
;; (define-extern menu-respond-to-pause function) ;; (function symbol)
|
|
;; (define-extern *menu-hook* function) ;; (function debug-menu-context)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; visvol-edit ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype visvol-edit-info (structure)
|
|
((editing basic :offset-assert 0)
|
|
(current-func uint64 :offset-assert 8)
|
|
(analog-func uint64 :offset-assert 16)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x18
|
|
:flag-assert #xc00000018
|
|
(:methods
|
|
(visvol-edit-info-method-9 () none) ;; 9
|
|
(visvol-edit-info-method-10 () none) ;; 10
|
|
(visvol-edit-info-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype visvol-editor (process)
|
|
((proc uint64 :offset-assert 128)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x88
|
|
:flag-assert #xf00100088
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *visvol-edit-info* object)
|
|
;; (define-extern visvol-editor-init-by-other function)
|
|
;; (define-extern stop-visvol-edit function)
|
|
;; (define-extern visvol-edit function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; collision-editor ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype collision-editor-default-proc (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collision-editor-edited-proc (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collision-editor (process)
|
|
((proc uint64 :offset-assert 128)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x88
|
|
:flag-assert #xf00100088
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype collision-edit-info (structure)
|
|
((editing basic :offset-assert 0)
|
|
(current-func uint64 :offset-assert 8)
|
|
(analog-func uint64 :offset-assert 16)
|
|
(current-prim int32 :offset-assert 24)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x1c
|
|
:flag-assert #xc0000001c
|
|
(:methods
|
|
(collision-edit-info-method-9 () none) ;; 9
|
|
(collision-edit-info-method-10 () none) ;; 10
|
|
(collision-edit-info-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern collision-editor-default-proc-init-by-other function)
|
|
;; (define-extern collision-editor-edited-proc-init-by-other function)
|
|
;; (define-extern *collision-editor-mesh-names* array)
|
|
;; (define-extern *collision-editor-art-group-name* string)
|
|
;; (define-extern collision-editor-add-mesh-to-ccache function)
|
|
;; (define-extern print-default-collision function)
|
|
;; (define-extern print-actual-collision function)
|
|
;; (define-extern collision-edit-get-max-prim function)
|
|
;; (define-extern collision-edit-get-prim function)
|
|
;; (define-extern *collision-edit-info* object)
|
|
;; (define-extern collision-editor-init-by-other function)
|
|
;; (define-extern stop-collision-edit function)
|
|
;; (define-extern collision-edit function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-sewl ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sewl-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; citizen-chick ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype citizen-chick (civilian)
|
|
()
|
|
:method-count-assert 234
|
|
:size-assert #x464
|
|
:flag-assert #xea03f00464
|
|
(:state-methods
|
|
knocked ;; 31
|
|
get-up-front ;; 220
|
|
get-up-back ;; 221
|
|
wait ;; 190
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *citizen-chick-global-info* civilian-global-info) ;; civilian-global-info
|
|
;; (define-extern *citizen-chick-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; palcab-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern palcab-bird-bob-func function) ;; (function sparticle-system sparticle-cpuinfo matrix none :behavior palcab-part)
|
|
;; (define-extern sparticle-palcab-bird-moon function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; texture-upload ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *generic-envmap-texture* object) ;; texture
|
|
;; (define-extern *default-envmap-shader* object) ;; adgif-shader
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dm-mine-spider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dm-mine-spider (nav-enemy)
|
|
((change-dir-time uint64 :offset-assert 624)
|
|
(last-change-dir uint64 :offset-assert 632)
|
|
(move-angle float :offset-assert 640)
|
|
(heading basic :offset-assert 644)
|
|
(size float :offset-assert 648)
|
|
(angle-spot float :offset-assert 652)
|
|
(trackable? basic :offset-assert 656)
|
|
)
|
|
:method-count-assert 194
|
|
:size-assert #x294
|
|
:flag-assert #xc202200294
|
|
(:methods
|
|
(dm-mine-spider-method-192 () none) ;; 192
|
|
(dm-mine-spider-method-193 () none) ;; 193
|
|
)
|
|
(:state-methods
|
|
attack ;; 191
|
|
knocked ;; 31
|
|
ambush ;; 47
|
|
run-stop ;; 190
|
|
hostile ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dm-mine-spider-spawner (process-focusable)
|
|
((count-alive int32 :offset-assert 208)
|
|
(attack-id uint32 :offset-assert 212)
|
|
(next-spawn-time uint64 :offset-assert 216)
|
|
(alt-actor basic :offset-assert 224)
|
|
(nav-id uint32 :offset-assert 228)
|
|
(num-nav-mesh int32 :offset-assert 232)
|
|
(count-max int32 :offset-assert 236)
|
|
(hit-points int32 :offset-assert 240)
|
|
(nav-sphere uint64 :offset-assert 248)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x100
|
|
:flag-assert #x2200800100
|
|
(:methods
|
|
(dm-mine-spider-spawner-method-30 () none) ;; 30
|
|
(dm-mine-spider-spawner-method-31 () none) ;; 31
|
|
(dm-mine-spider-spawner-method-32 () none) ;; 32
|
|
(dm-mine-spider-spawner-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern check-drop-level-dm-mine-spider-dirt-rubble function)
|
|
;; (define-extern spt-birth-func-brightness-dm-mine-spider function)
|
|
;; (define-extern spt-birth-func-part-dm-mine-spider-clumps function)
|
|
;; (define-extern spt-func-part-dm-mine-spider-clumps function)
|
|
;; (define-extern spt-birth-func-part-dm-mine-spider-clumps-mass function)
|
|
;; (define-extern spt-func-part-dm-mine-spider-clumps-mass function)
|
|
;; (define-extern spt-birth-func-part-dm-mine-spider-clumps-pop function)
|
|
;; (define-extern spt-func-part-dm-mine-spider-clumps-pop function)
|
|
;; (define-extern spt-birth-func-part-dm-mine-spider-clumps-stays function)
|
|
;; (define-extern spt-func-part-dm-mine-spider-clumps-stays function)
|
|
;; (define-extern *dm-mine-spider-nav-enemy-info* nav-enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasdoors-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wasdoors-manager (process)
|
|
((name basic :offset-assert 0)
|
|
(mask process-mask :offset-assert 4)
|
|
(clock basic :offset-assert 8)
|
|
(parent uint32 :offset-assert 12)
|
|
(brother uint32 :offset-assert 16)
|
|
(child uint32 :offset-assert 20)
|
|
(ppointer uint32 :offset-assert 24)
|
|
(self basic :offset-assert 28)
|
|
(pool basic :offset-assert 32)
|
|
(status basic :offset-assert 36)
|
|
(pid int32 :offset-assert 40)
|
|
(main-thread basic :offset-assert 44)
|
|
(top-thread basic :offset-assert 48)
|
|
(entity basic :offset-assert 52)
|
|
(level basic :offset-assert 56)
|
|
(state basic :offset-assert 60)
|
|
(prev-state basic :offset-assert 64)
|
|
(next-state basic :offset-assert 68)
|
|
(state-stack basic :offset-assert 72)
|
|
(trans-hook basic :offset-assert 76)
|
|
(post-hook basic :offset-assert 80)
|
|
(event-hook basic :offset-assert 84)
|
|
(allocated-length int32 :offset-assert 88)
|
|
(heap-base uint32 :offset-assert 92)
|
|
(heap-top uint32 :offset-assert 96)
|
|
(heap-cur uint32 :offset-assert 100)
|
|
(stack-frame-top basic :offset-assert 104)
|
|
(heap kheap :inline :offset-assert 92)
|
|
(connection-list connectable :inline :offset-assert 108)
|
|
(stack UNKNOWN :dynamic :offset-assert 124)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x80
|
|
:flag-assert #x1000000080
|
|
(:methods
|
|
(wasdoors-manager-method-15 () none) ;; 15
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern wasdoors-point-inside? function)
|
|
;; (define-extern wasdoors-cleanup function)
|
|
;; (define-extern wasdoors-manager-init-by-other function)
|
|
;; (define-extern *wasdoors-manager* object)
|
|
;; (define-extern wasdoors-manager-start function)
|
|
;; (define-extern wasdoors-manager-kill function)
|
|
;; (define-extern wasdoors-activate function)
|
|
;; (define-extern wasdoors-deactivate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; texture-finish ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; los-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype los-control (structure)
|
|
((src-proc uint64 :offset-assert 0) ;; handle
|
|
(dst-proc uint64 :offset-assert 8) ;; handle
|
|
(last-lost-los uint64 :offset-assert 16)
|
|
(last-gained-los uint64 :offset-assert 24)
|
|
(check-interval uint64 :offset-assert 32) ;; time-frame
|
|
(max-check-distance float :offset-assert 40)
|
|
(last-check-time uint64 :offset-assert 48) ;; time-frame
|
|
(last-collide-result collide-tri-result :inline :offset-assert 64)
|
|
(collide-with collide-spec :offset-assert 160) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #xa4
|
|
:flag-assert #xe000000a4
|
|
(:methods
|
|
(los-control-method-9 () none) ;; 9 ;; (los-control-method-9 (_type_ process-focusable vector float) none 9)
|
|
(los-control-method-10 () none) ;; 10 ;; (check-los? (_type_ time-frame) symbol 10)
|
|
(los-control-method-11 () none) ;; 11 ;; (skip-check-los? (_type_ int) symbol 11)
|
|
(los-control-method-12 () none) ;; 12 ;; (set-dst-proc! (_type_ handle) none 12)
|
|
(los-control-method-13 () none) ;; 13 ;; (new-source! (_type_ process time-frame collide-spec) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; airlock ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype com-airlock (process-drawable)
|
|
((level-name pair :offset-assert 196) ;; guessed by decompiler
|
|
(open-test pair :offset-assert 200) ;; guessed by decompiler
|
|
(on-running basic :offset-assert 204)
|
|
(were-behind? symbol :offset-assert 208) ;; guessed by decompiler
|
|
(inner? symbol :offset-assert 212) ;; guessed by decompiler
|
|
(sound-behind? symbol :offset-assert 216) ;; guessed by decompiler
|
|
(visible-move? symbol :offset-assert 220) ;; guessed by decompiler
|
|
(saw-pilot? uint64 :offset-assert 228) ;; handle
|
|
(last-distance meters :offset-assert 236)
|
|
(y-height vector :offset-assert 240) ;; guessed by decompiler
|
|
(pre-open-speed float :offset-assert 244)
|
|
(open? basic :offset-assert 248)
|
|
(latch-closed-time uint64 :offset-assert 252) ;; time-frame
|
|
(latch-open-time uint64 :offset-assert 260) ;; time-frame
|
|
(gear joint-mod :offset-assert 268) ;; guessed by decompiler
|
|
(gear-rot deg :offset-assert 272) ;; degrees
|
|
(gear-rotv deg :offset-assert 276) ;; degrees
|
|
(gear-start-frame float :offset-assert 280)
|
|
(gear-stop-frame float :offset-assert 284)
|
|
(gear-play-time uint64 :offset-assert 292)
|
|
(open-frame float :offset-assert 300)
|
|
(pre-open-frame float :offset-assert 304)
|
|
(lock-frame float :offset-assert 308)
|
|
(close-speed-multiplier float :offset-assert 312)
|
|
(open-distance meters 2 :offset-assert 316) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(active-distance meters 2 :offset-assert 324) ;; guessed by decompiler
|
|
(UNKNOWN UNKNOWN :offset-assert -1) ;; field could not be read.
|
|
(sound-id sound-id :offset-assert 332) ;; guessed by decompiler
|
|
(gear-sound-id sound-id :offset-assert 336) ;; guessed by decompiler
|
|
(sound-gear sound-spec :offset-assert 340) ;; guessed by decompiler
|
|
(sound-pre-open sound-spec :offset-assert 344) ;; guessed by decompiler
|
|
(sound-pre-open-stop sound-spec :offset-assert 348) ;; guessed by decompiler
|
|
(sound-lock-loop sound-spec :offset-assert 352) ;; guessed by decompiler
|
|
(sound-lock-stop sound-spec :offset-assert 356) ;; guessed by decompiler
|
|
(sound-open sound-spec :offset-assert 360) ;; guessed by decompiler
|
|
(sound-open-loop sound-spec :offset-assert 364) ;; guessed by decompiler
|
|
(sound-open-stop sound-spec :offset-assert 368) ;; guessed by decompiler
|
|
(sound-close sound-spec :offset-assert 372) ;; guessed by decompiler
|
|
(sound-close-loop sound-spec :offset-assert 376) ;; guessed by decompiler
|
|
(sound-close-stop sound-spec :offset-assert 380) ;; guessed by decompiler
|
|
(sound-post-close sound-spec :offset-assert 384) ;; guessed by decompiler
|
|
(sound-post-close-stop sound-spec :offset-assert 388) ;; guessed by decompiler
|
|
(spool-sound-time uint64 :offset-assert 396) ;; time-frame
|
|
(start-open-time uint64 :offset-assert 404)
|
|
(door-radius meters :offset-assert 412)
|
|
(allow-pilot? basic :offset-assert 416)
|
|
(allow-flut? basic :offset-assert 420)
|
|
(blocking-plane? basic :offset-assert 424)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
;; field level-name uses ~A with a signed load. field open-test uses ~A with a signed load. field on-running uses ~A with a signed load.
|
|
(:methods
|
|
(com-airlock-method-22 () none) ;; 22 ;; (init-airlock! (_type_) _type_ 22)
|
|
(com-airlock-method-23 () none) ;; 23 ;; (want-cross-airlock? (_type_) symbol 23)
|
|
(com-airlock-method-24 () none) ;; 24 ;; (destination-loaded? (_type_ symbol) symbol 24)
|
|
(com-airlock-method-25 () none) ;; 25 ;; (check-crossing-distance (_type_ vector symbol) float 25)
|
|
(com-airlock-method-26 () none) ;; 26 ;; (rotate-gear! (_type_ float) degrees 26)
|
|
(com-airlock-method-27 () none) ;; 27 ;; (play-city-voice-sound (_type_ symbol) none 27)
|
|
(com-airlock-method-28 () none) ;; 28
|
|
(com-airlock-method-29 () none) ;; 29
|
|
)
|
|
(:state-methods
|
|
close ;; 21, old: (close (symbol) _type_ :state 21)
|
|
open ;; 20, old: (open (symbol) _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype com-airlock-outer (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype com-airlock-inner (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vin-door-ctyinda (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype com-airlock-outer-mhcity (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hip-door-a (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern airlock-stop-part-trackers function)
|
|
;; (define-extern airlock-command-lookup function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; water-anim ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype water-anim (process-drawable)
|
|
((water-height meters :offset-assert 200)
|
|
(wade-height meters :offset-assert 204)
|
|
(swim-height meters :offset-assert 208)
|
|
(bottom-height meters :offset-assert 212)
|
|
(attack-event symbol :offset-assert 216) ;; guessed by decompiler
|
|
(attack-id uint32 :offset-assert 220)
|
|
(flow flow-control :offset-assert 224) ;; guessed by decompiler
|
|
(target uint64 :offset-assert 232) ;; handle
|
|
(flags water-flags :offset-assert 240) ;; guessed by decompiler
|
|
(look int32 :offset-assert 244)
|
|
(play-ambient-sound? symbol :offset-assert 248) ;; guessed by decompiler
|
|
(visible symbol :offset-assert 252) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
(:methods
|
|
(water-anim-method-20 () none) ;; 20 ;; (water-anim-state-20 () _type_ :state 20)
|
|
(water-anim-method-22 () none) ;; 22 ;; (move-to-point! (_type_ vector) int 22)
|
|
(water-anim-method-23 () none) ;; 23 ;; (get-ripple-height (_type_ vector) float 23)
|
|
(water-anim-method-24 () none) ;; 24 ;; (init-water! (_type_) none 24)
|
|
(water-anim-method-25 () none) ;; 25 ;; (reset-root! (_type_) trsqv 25)
|
|
(water-anim-method-26 () none) ;; 26 ;; (water-anim-init! (_type_) none 26)
|
|
(water-anim-method-27 () none) ;; 27 ;; (water-anim-method-27 (_type_) none 27)
|
|
(water-anim-method-28 () none) ;; 28 ;; (offset! (_type_) none 28)
|
|
)
|
|
(:state-methods
|
|
idle ;; 21, old: (idle () _type_ :state 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype water-anim-look (structure)
|
|
((skel-group string :offset-assert 0) ;; guessed by decompiler
|
|
(anim int32 :offset-assert 4)
|
|
(ambient-sound-spec sound-spec :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *water-anim-look* array) ;; (array water-anim-look)
|
|
;; (define-extern water-anim-event-handler function) ;; (function process int symbol event-message-block object :behavior water-anim)
|
|
;; (define-extern water-anim-init-by-other function) ;; (function entity-actor none :behavior water-anim)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blocking-plane ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype blocking-plane (process-drawable)
|
|
((current-attack-mode basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:methods
|
|
(blocking-plane-method-21 () none) ;; 21 ;; (init! (_type_ (inline-array vector) float) none 21)
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern blocking-plane-init-by-other function) ;; (function (inline-array vector) float none :behavior blocking-plane)
|
|
;; (define-extern blocking-plane-spawn function) ;; (function curve-control (inline-array vector) float none :behavior process)
|
|
;; (define-extern blocking-plane-destroy function) ;; (function none :behavior blocking-plane)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; proc-focusable-spawner ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype proc-focusable-spawn-record (structure)
|
|
((proc uint64 :offset-assert 0)
|
|
(index int16 :offset-assert 8)
|
|
(dead-time uint64 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype proc-focusable-spawn-record-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype proc-focusable-spawner (basic)
|
|
((records basic :offset-assert 4)
|
|
(unused-list basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #xc
|
|
:flag-assert #x110000000c
|
|
(:methods
|
|
(proc-focusable-spawner-method-9 () none) ;; 9
|
|
(proc-focusable-spawner-method-10 () none) ;; 10
|
|
(proc-focusable-spawner-method-11 () none) ;; 11
|
|
(proc-focusable-spawner-method-12 () none) ;; 12
|
|
(proc-focusable-spawner-method-13 () none) ;; 13
|
|
(proc-focusable-spawner-method-14 () none) ;; 14
|
|
(proc-focusable-spawner-method-15 () none) ;; 15
|
|
(proc-focusable-spawner-method-16 () none) ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-enemy-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-enemy-info (enemy-info)
|
|
((callback-info nav-callback-info :offset-assert 420)
|
|
(use-momentum symbol :offset-assert 424) ;; guessed by decompiler
|
|
(use-frustration symbol :offset-assert 428) ;; guessed by decompiler
|
|
(use-stop-chase symbol :offset-assert 432) ;; guessed by decompiler
|
|
(use-circling symbol :offset-assert 436) ;; guessed by decompiler
|
|
(use-pacing symbol :offset-assert 440) ;; guessed by decompiler
|
|
(walk-anim int32 :offset-assert 444)
|
|
(turn-anim int32 :offset-assert 448)
|
|
(run-anim int32 :offset-assert 452)
|
|
(taunt-anim int32 :offset-assert 456)
|
|
(run-travel-speed meters :offset-assert 460)
|
|
(run-acceleration meters :offset-assert 464)
|
|
(run-turning-acceleration meters :offset-assert 468)
|
|
(walk-travel-speed meters :offset-assert 472)
|
|
(walk-acceleration meters :offset-assert 476)
|
|
(walk-turning-acceleration meters :offset-assert 480)
|
|
(maximum-rotation-rate deg :offset-assert 484) ;; degrees
|
|
(notice-nav-radius meters :offset-assert 488)
|
|
(frustration-distance meters :offset-assert 492)
|
|
(frustration-time uint64 :offset-assert 496) ;; time-frame
|
|
(blocked-time uint64 :offset-assert 504) ;; time-frame
|
|
(circle-dist-lo float :offset-assert 512)
|
|
(circle-dist-hi float :offset-assert 516)
|
|
(nav-mesh nav-mesh :offset-assert 520) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x20c
|
|
:flag-assert #xb0000020c
|
|
(:methods
|
|
(nav-enemy-info-method-10 () none) ;; 10 ;; (copy-nav-enemy-info! (_type_ nav-enemy-info) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-enemy (enemy)
|
|
((frustration-point vector :inline :offset-assert 560)
|
|
(move-dest vector :inline :offset-assert 576)
|
|
(frustration-time uint64 :offset-assert 592) ;; time-frame
|
|
(blocked-start-time uint64 :offset-assert 600) ;; time-frame
|
|
(restore-nav-radius-time uint64 :offset-assert 608) ;; time-frame
|
|
(nav-radius-backup float :offset-assert 616)
|
|
(circle-radial-dist float :offset-assert 244)
|
|
)
|
|
:method-count-assert 190
|
|
:size-assert #x26c
|
|
:flag-assert #xbe01f0026c
|
|
(:methods
|
|
(nav-enemy-method-155 () none) ;; 155 ;; (nav-enemy-method-155 (_type_) none 155)
|
|
(nav-enemy-method-156 () none) ;; 156 ;; (nav-enemy-method-156 (_type_) none 156)
|
|
(nav-enemy-method-157 () none) ;; 157 ;; (nav-enemy-method-157 (_type_ vector) nav-poly 157)
|
|
(nav-enemy-method-158 () none) ;; 158 ;; (nav-enemy-method-158 (_type_ vector) object 158)
|
|
(nav-enemy-method-159 () none) ;; 159 ;; (nav-enemy-method-159 (_type_ vector) symbol 159)
|
|
(nav-enemy-method-160 () none) ;; 160 ;; (nav-enemy-method-160 (_type_) none 160)
|
|
(nav-enemy-method-161 () none) ;; 161 ;; (nav-enemy-method-161 (_type_) none 161)
|
|
(nav-enemy-method-162 () none) ;; 162 ;; (nav-enemy-method-162 (_type_) none 162)
|
|
(nav-enemy-method-163 () none) ;; 163 ;; (nav-enemy-method-163 (_type_) symbol 163)
|
|
(nav-enemy-method-164 () none) ;; 164 ;; (nav-enemy-method-164 (_type_) none 164)
|
|
(nav-enemy-method-165 () none) ;; 165 ;; (nav-enemy-method-165 (_type_) none 165)
|
|
(nav-enemy-method-166 () none) ;; 166 ;; (nav-enemy-method-166 (_type_) none 166)
|
|
(nav-enemy-method-167 () none) ;; 167 ;; (nav-enemy-method-167 (_type_) none 167)
|
|
(nav-enemy-method-168 () none) ;; 168 ;; (nav-enemy-method-168 (_type_) float 168)
|
|
(nav-enemy-method-169 () none) ;; 169 ;; (nav-enemy-method-169 (_type_ float symbol) float 169)
|
|
(nav-enemy-method-170 () none) ;; 170 ;; (nav-enemy-method-170 (_type_) none 170)
|
|
(nav-enemy-method-171 () none) ;; 171 ;; (nav-enemy-method-171 (_type_) none 171)
|
|
(nav-enemy-method-172 () none) ;; 172 ;; (nav-enemy-method-172 (_type_) none 172)
|
|
(nav-enemy-method-173 () none) ;; 173 ;; (nav-enemy-method-173 (_type_) none 173)
|
|
(nav-enemy-method-174 () none) ;; 174 ;; (nav-enemy-method-174 (_type_) symbol 174)
|
|
(nav-enemy-method-175 () none) ;; 175 ;; (nav-enemy-method-175 (_type_) symbol 175)
|
|
(nav-enemy-method-176 () none) ;; 176 ;; (nav-enemy-method-176 (_type_) none 176)
|
|
(nav-enemy-method-177 () none) ;; 177 ;; (nav-enemy-method-177 (_type_) none 177)
|
|
(nav-enemy-method-178 () none) ;; 178
|
|
(nav-enemy-method-179 () none) ;; 179
|
|
(nav-enemy-method-180 () none) ;; 180
|
|
(nav-enemy-method-181 () none) ;; 181
|
|
(nav-enemy-method-182 () none) ;; 182
|
|
(nav-enemy-method-183 () none) ;; 183
|
|
(nav-enemy-method-184 () none) ;; 184
|
|
(nav-enemy-method-185 () none) ;; 185
|
|
(nav-enemy-method-186 () none) ;; 186
|
|
(nav-enemy-method-187 () none) ;; 187
|
|
(nav-enemy-method-188 () none) ;; 188
|
|
(nav-enemy-method-189 () none) ;; 189
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-enemy-debug-control-info (basic)
|
|
((enable basic :offset-assert 4)
|
|
(steering float :offset-assert 8)
|
|
(throttle float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; temple-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern temple-lightjak-do-effect function)
|
|
;; (define-extern temple-lightjak-wings-do-effect function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; plat ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype plat (base-plat)
|
|
((path-pos float :offset-assert 272)
|
|
(sound-id sound-id :offset-assert 276) ;; guessed by decompiler
|
|
(sync sync-eased :inline :offset-assert 280)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x144
|
|
:flag-assert #x2600d00144
|
|
(:methods
|
|
(plat-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
plat-idle ;; 35, old: (plat-path-active () _type_ :state 35)
|
|
plat-path-active ;; 36, old: (plat-path-sync (_type_) object 36)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype drop-plat (base-plat)
|
|
((art-name string :offset-assert 272) ;; guessed by decompiler
|
|
(anim spool-anim :offset-assert 276) ;; guessed by decompiler
|
|
(break-anim-name string :offset-assert 280) ;; guessed by decompiler
|
|
(safe-time uint64 :offset-assert 288) ;; time-frame
|
|
(hit-point vector :inline :offset-assert 304)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x140
|
|
:flag-assert #x2500c00140
|
|
(:state-methods
|
|
idle ;; 35, old: (fall (symbol) _type_ :state 35)
|
|
fall ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; king-rider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype king-rider (process-focusable)
|
|
((front-back-interp float :offset-assert 208)
|
|
(left-right-interp float :offset-assert 212)
|
|
(up-down-interp float :offset-assert 216)
|
|
(complain-time uint64 :offset-assert 224)
|
|
(complain-speech int32 :offset-assert 232)
|
|
(last-moved-time uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #xf8
|
|
:flag-assert #x1e008000f8
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern king-pilot-trans function)
|
|
;; (define-extern king-pilot-wcar-anim-loop function)
|
|
;; (define-extern king-rider-init-by-other function)
|
|
;; (define-extern king-rider-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rigid-body ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rigid-body-work (structure)
|
|
((max-ang-momentum float :offset-assert 0)
|
|
(max-ang-velocity float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-move-work (structure)
|
|
((cquery collide-query :inline :offset-assert 0)
|
|
(mat matrix :inline :offset-assert 544)
|
|
(impact-info rigid-body-impact :inline :offset-assert 608)
|
|
(impact-info2 rigid-body-impact :inline :offset-assert 672)
|
|
(orig-position vector :inline :offset-assert 736)
|
|
(orig-rotation quaternion :inline :offset-assert 752)
|
|
(force vector :inline :offset-assert 768)
|
|
(vel vector :inline :offset-assert 784)
|
|
(p-body vector :inline :offset-assert 800)
|
|
(tmp vector :inline :offset-assert 816)
|
|
(tangent-dir vector :inline :offset-assert 832)
|
|
(proc2 basic :offset-assert 848)
|
|
(rbody2 basic :offset-assert 852)
|
|
(vel-dot-norm float :offset-assert 856)
|
|
(denom float :offset-assert 860)
|
|
(denom2 float :offset-assert 864)
|
|
(time-step float :offset-assert 868)
|
|
(time-step-scale float :offset-assert 872)
|
|
(step-count int8 :offset-assert 876)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x36d
|
|
:flag-assert #x90000036d
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *rigid-body-work* object) ;; rigid-body-work
|
|
;; (define-extern matrix-3x3-triple-transpose-product function) ;; (function matrix matrix matrix matrix)
|
|
;; (define-extern damping-time-adjust function) ;; (function float float float)
|
|
;; (define-extern transform-rigid-body-prims function) ;; (function collide-shape-prim matrix symbol)
|
|
;; (define-extern *rigid-body-object-constants* object) ;; rigid-body-object-constants
|
|
;; (define-extern rigid-body-object-event-handler function) ;; (function process int symbol event-message-block object :behavior rigid-body-object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rigid-body-queue ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rigid-body-queue-manager (process)
|
|
((queue rigid-body-queue :offset-assert 128)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x84
|
|
:flag-assert #xf00100084
|
|
(:state-methods
|
|
idle ;; 14, old: (idle () _type_ :state 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *rigid-body-queue-manager* object)
|
|
;; (define-extern rigid-body-queue-manager-init-by-other function) ;; (function rigid-body-queue object :behavior rigid-body-queue-manager)
|
|
;; (define-extern rigid-body-queue-manager-spawn function) ;; (function rigid-body-queue process-tree process)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rigid-body-plat ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rigid-body-platform-constants (rigid-body-object-constants)
|
|
((drag-factor float :offset-assert 208)
|
|
(buoyancy-factor float :offset-assert 212)
|
|
(max-buoyancy-depth meters :offset-assert 216)
|
|
(player-weight meters :offset-assert 220)
|
|
(player-bonk-factor float :offset-assert 224)
|
|
(player-dive-factor float :offset-assert 228)
|
|
(player-force-distance meters :offset-assert 232)
|
|
(player-force-clamp meters :offset-assert 236)
|
|
(player-force-timeout uint64 :offset-assert 240)
|
|
(explosion-force meters :offset-assert 248)
|
|
(control-point-count int32 :offset-assert 252)
|
|
(platform symbol :offset-assert 256) ;; guessed by decompiler
|
|
(sound-name string :offset-assert 260) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x108
|
|
:flag-assert #x900000108
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-control-point (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(world-pos vector :inline :offset-assert 16)
|
|
(velocity vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-control-point-inline-array (inline-array-class)
|
|
((data rigid-body-control-point :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-platform (rigid-body-object)
|
|
((control-point-array rigid-body-control-point-inline-array :offset-assert 288) ;; guessed by decompiler
|
|
(float-height-offset float :offset-assert 292)
|
|
(player-bonk-timeout uint64 :offset-assert 296)
|
|
(water-anim water-anim :offset-assert 304) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 60
|
|
:size-assert #x134
|
|
:flag-assert #x3c00c00134
|
|
(:methods
|
|
(rigid-body-platform-method-56 () none) ;; 56 ;; (rigid-body-platform-method-56 (_type_ vector) none 56)
|
|
(rigid-body-platform-method-57 () none) ;; 57
|
|
(rigid-body-platform-method-58 () none) ;; 58
|
|
(rigid-body-platform-method-59 () none) ;; 59
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *rigid-body-platform-constants* object) ;; rigid-body-platform-constants
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prebot-setup ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype prebot-eco-pillar-launch-spec (structure)
|
|
((offset vector :offset-assert 0)
|
|
(height float :offset-assert 4)
|
|
(style int8 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x9
|
|
:flag-assert #x900000009
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-eco-pillar (process-drawable)
|
|
((vulnerable basic :offset-assert 200)
|
|
(hot basic :offset-assert 204)
|
|
(start-y float :offset-assert 208)
|
|
(end-y float :offset-assert 212)
|
|
(heat-part basic :offset-assert 216)
|
|
(cool-part basic :offset-assert 220)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xe0
|
|
:flag-assert #x1a006000e0
|
|
(:methods
|
|
(prebot-eco-pillar-method-20 () none) ;; 20
|
|
(prebot-eco-pillar-method-21 () none) ;; 21
|
|
(prebot-eco-pillar-method-22 () none) ;; 22
|
|
(prebot-eco-pillar-method-23 () none) ;; 23
|
|
(prebot-eco-pillar-method-24 () none) ;; 24
|
|
(prebot-eco-pillar-method-25 () none) ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cav-railblocker (process-focusable)
|
|
((incoming-attack-id uint32 :offset-assert 208)
|
|
(hit-points float :offset-assert 212)
|
|
(notify-on-die basic :offset-assert 216)
|
|
(notify-on-die-2 basic :offset-assert 220)
|
|
(trackable basic :offset-assert 224)
|
|
(red-tip-change-time uint64 :offset-assert 232)
|
|
(alt-red-tip-on basic :offset-assert 240)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #xf4
|
|
:flag-assert #x1f008000f4
|
|
(:methods
|
|
(cav-railblocker-method-28 () none) ;; 28
|
|
(cav-railblocker-method-29 () none) ;; 29
|
|
(cav-railblocker-method-30 () none) ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cav-minecar (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:methods
|
|
(cav-minecar-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-sword (process-drawable)
|
|
((prefix basic :offset-assert 200)
|
|
(blade-scale cam-float-seeker :inline :offset-assert 204)
|
|
(blade-jm basic :offset-assert 228)
|
|
(sword-sound uint32 :offset-assert 232)
|
|
(sword-sound-playing basic :offset-assert 236)
|
|
(prev-position vector :inline :offset-assert 240)
|
|
(use-pos-pitch basic :offset-assert 256)
|
|
(old-target-dist float :offset-assert 260)
|
|
(alternate-sound basic :offset-assert 264)
|
|
(whoosh-lead float :offset-assert 268)
|
|
(allow-whoosh basic :offset-assert 272)
|
|
(current-volume float :offset-assert 276)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x118
|
|
:flag-assert #x1500a00118
|
|
(:methods
|
|
(prebot-sword-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-shockwave (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:methods
|
|
(prebot-shockwave-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-gun (process-drawable)
|
|
((prefix basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:methods
|
|
(prebot-gun-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-tentacle (process-drawable)
|
|
((prefix basic :offset-assert 200)
|
|
(aim-jm basic :offset-assert 204)
|
|
(half-aim-jm basic :offset-assert 208)
|
|
(laser-sound uint32 :offset-assert 212)
|
|
(laser-sound-playing basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xdc
|
|
:flag-assert #x15006000dc
|
|
(:methods
|
|
(prebot-tentacle-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-ammo-tracker (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(where vector :inline :offset-assert 16)
|
|
(birth-next-time basic :offset-assert 32)
|
|
(timer uint64 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot (process-focusable)
|
|
((critters UNKNOWN 28 :offset-assert 208)
|
|
(critters-to-launch int8 :offset-assert 432)
|
|
(gun uint64 :offset-assert 440)
|
|
(swords UNKNOWN 2 :offset-assert 448)
|
|
(tentacles UNKNOWN 5 :offset-assert 464)
|
|
(beam-projectile uint64 :offset-assert 504)
|
|
(pillars UNKNOWN 5 :offset-assert 512)
|
|
(original-position vector :inline :offset-assert 560)
|
|
(position cam-vector-seeker :inline :offset-assert 576)
|
|
(stage int8 :offset-assert 636)
|
|
(stage-hit-points float :offset-assert 640)
|
|
(last-attack-id uint32 :offset-assert 644)
|
|
(neck-angle cam-float-seeker :inline :offset-assert 648)
|
|
(no-collision-timer uint64 :offset-assert 672)
|
|
(num-attacks uint8 :offset-assert 680)
|
|
(shoulder-aim-jm basic :offset-assert 684)
|
|
(shot-extra-y float :offset-assert 688)
|
|
(shot-extra-xz float :offset-assert 692)
|
|
(which-movie int8 :offset-assert 696)
|
|
(light-flash cam-vector-seeker :inline :offset-assert 704)
|
|
(light-pulse oscillating-vector :inline :offset-assert 768)
|
|
(light-pulse-flicker delayed-rand-vector :inline :offset-assert 832)
|
|
(laugh-played basic :offset-assert 880)
|
|
(grunt-played basic :offset-assert 884)
|
|
(trythis-played basic :offset-assert 888)
|
|
(laugh-timer uint64 :offset-assert 896)
|
|
(blocker uint64 :offset-assert 904)
|
|
(flags uint32 :offset-assert 912)
|
|
(pillar-hint-timer uint64 :offset-assert 920)
|
|
(minecar-hint-timer uint64 :offset-assert 928)
|
|
(ammo UNKNOWN 20 :offset-assert 944)
|
|
)
|
|
:method-count-assert 47
|
|
:size-assert #x770
|
|
:flag-assert #x2f06f00770
|
|
(:methods
|
|
(prebot-method-28 () none) ;; 28
|
|
(prebot-method-29 () none) ;; 29
|
|
(prebot-method-30 () none) ;; 30
|
|
(prebot-method-31 () none) ;; 31
|
|
(prebot-method-32 () none) ;; 32
|
|
(prebot-method-33 () none) ;; 33
|
|
(prebot-method-34 () none) ;; 34
|
|
(prebot-method-35 () none) ;; 35
|
|
(prebot-method-36 () none) ;; 36
|
|
(prebot-method-37 () none) ;; 37
|
|
(prebot-method-38 () none) ;; 38
|
|
(prebot-method-39 () none) ;; 39
|
|
(prebot-method-40 () none) ;; 40
|
|
(prebot-method-41 () none) ;; 41
|
|
(prebot-method-42 () none) ;; 42
|
|
(prebot-method-43 () none) ;; 43
|
|
(prebot-method-44 () none) ;; 44
|
|
(prebot-method-45 () none) ;; 45
|
|
(prebot-method-46 () none) ;; 46
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *cav-railblocker-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern prebot-eco-pillar-init-by-other function)
|
|
;; (define-extern *prebot-sword-color-curve* object)
|
|
;; (define-extern *prebot-sword-white-red-curve* object)
|
|
;; (define-extern *prebot-sword-width-curve* curve2d-fast)
|
|
;; (define-extern *prebot-sword-color-array* object)
|
|
;; (define-extern prebot-sword-init-by-other function)
|
|
;; (define-extern prebot-shockwave-init-by-other function)
|
|
;; (define-extern prebot-gun-init-by-other function)
|
|
;; (define-extern prebot-tentacle-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; simple-nav-sphere ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype simple-nav-sphere (process-drawable)
|
|
((first-time? symbol :offset-assert 200) ;; guessed by decompiler
|
|
(track-joint int32 :offset-assert 204)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd0
|
|
:flag-assert #x16005000d0
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
active ;; 21, old: (active () _type_ :state 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern simple-nav-sphere-event-handler function) ;; (function process int symbol event-message-block object :behavior simple-nav-sphere)
|
|
;; (define-extern simple-nav-sphere-init-by-other function) ;; (function float vector nav-mesh int none :behavior simple-nav-sphere)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; scene-actor ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pecker-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype veger-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ashelin-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype damus-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype torn-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype samos-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sig-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kleever-npc (process-taskable)
|
|
((cloth basic :offset-assert 280)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x11c
|
|
:flag-assert #x2800a0011c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype seem-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype onin-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype jinx-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tess-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vin-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype keira-npc (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
;; (define-extern pre-intro-play function)
|
|
;; (define-extern intro-play function) ;; (function none)
|
|
;; (define-extern outro-play function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; process-taskable ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern process-taskable-anim-loop function) ;; (function (function process-taskable object) none :behavior process-taskable)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tower-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tower-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ltowerb-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-ltowerb function)
|
|
;; (define-extern init-mood-tower function)
|
|
;; (define-extern update-tower-lights function)
|
|
;; (define-extern update-mood-tower function)
|
|
;; (define-extern *towerb-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; metalhead-projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype metalhead-shot (projectile)
|
|
((tail-pos vector :inline :offset-assert 512)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x210
|
|
:flag-assert #x2901900210
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype metalhead-grenade-shot (projectile)
|
|
((tumble-quat quaternion :inline :offset-assert 512)
|
|
(blast-radius float :offset-assert 528)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x214
|
|
:flag-assert #x2901a00214
|
|
(:state-methods
|
|
impact ;; 22
|
|
dissipate ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern metalhead-shot-move function) ;; (function metalhead-shot none)
|
|
;; (define-extern spawn-metalhead-projectile function) ;; (function metalhead-shot vector vector float (pointer metalhead-shot))
|
|
;; (define-extern gren-canister-move function) ;; (function metalhead-grenade-shot none)
|
|
;; (define-extern gren-cshape-reaction-canister function) ;; (function collide-shape-moving metalhead-grenade-shot none)
|
|
;; (define-extern spawn-metalhead-grenade function) ;; (function metalhead-grenade-shot vector vector float (pointer metalhead-grenade-shot))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; chain-physics ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern chain-physics-initialize function) ;; (function process-drawable chain-physics int float (array chain-physics-setup) int)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; los-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *los-time-offset* object) ;; time-frame
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; enemy-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; monster-frog ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype monster-frog (nav-enemy)
|
|
()
|
|
:method-count-assert 193
|
|
:size-assert #x26c
|
|
:flag-assert #xc101f0026c
|
|
(:state-methods
|
|
ambush ;; 47
|
|
notice ;; 35
|
|
active ;; 34
|
|
pacing ;; 156
|
|
stare ;; 37
|
|
circling ;; 157
|
|
hostile ;; 38
|
|
turn ;; 192
|
|
attack ;; 190
|
|
attack-recover ;; 191
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-monster-frog-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *monster-frog-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern monster-frog-hop-slow-code function) ;; (function symbol :behavior monster-frog)
|
|
;; (define-extern monster-frog-hop-fast-code function) ;; (function symbol :behavior monster-frog)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; debris ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype debris-static-joint-params (structure)
|
|
((parent-joint-index int16 :offset-assert 0)
|
|
(group basic :offset-assert 4)
|
|
(offset vector :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debris-static-params (basic)
|
|
((joints basic :offset-assert 4)
|
|
(collide-spec uint32 :offset-assert 8)
|
|
(sound-hit uint128 :offset-assert 16)
|
|
(art-level basic :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debris (basic)
|
|
((root transformq :inline :offset-assert 16)
|
|
(node-list basic :offset-assert 64)
|
|
(draw basic :offset-assert 68)
|
|
(duration float :offset-assert 72)
|
|
(hit-xz-reaction float :offset-assert 76)
|
|
(hit-y-reaction float :offset-assert 80)
|
|
(prev-pos vector :inline :offset-assert 96)
|
|
(gravity float :offset-assert 112)
|
|
(rot-axis vector :inline :offset-assert 128)
|
|
(rot-angle float :offset-assert 144)
|
|
(transv vector :inline :offset-assert 160)
|
|
(time-fade-out uint64 :offset-assert 176)
|
|
(params basic :offset-assert 184)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xbc
|
|
:flag-assert #x9000000bc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debris-box (structure)
|
|
((start uint32 :offset-assert 0)
|
|
(num uint32 :offset-assert 4)
|
|
(bbox bounding-box :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debris-group (process)
|
|
((dead-debris-num int32 :offset-assert 128)
|
|
(debris-num int32 :offset-assert 132)
|
|
(debris basic :offset-assert 136)
|
|
(max-probe-width float :offset-assert 140)
|
|
(state-time uint64 :offset-assert 144)
|
|
(num-boxes uint32 :offset-assert 152)
|
|
(boxes UNKNOWN 16 :offset-assert 160)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x3a0
|
|
:flag-assert #x11032003a0
|
|
(:methods
|
|
(debris-group-method-15 () none) ;; 15
|
|
(debris-group-method-16 () none) ;; 16
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype debris-tuning (structure)
|
|
((explosion uint64 :offset-assert 0)
|
|
(duration uint64 :offset-assert 8)
|
|
(gravity float :offset-assert 16)
|
|
(rot-speed float :offset-assert 20)
|
|
(bounds-inflate float :offset-assert 24)
|
|
(max-probe-width float :offset-assert 28)
|
|
(max-probe-height float :offset-assert 32)
|
|
(max-probe-depth float :offset-assert 36)
|
|
(fountain-rand-transv-lo vector :inline :offset-assert 48)
|
|
(fountain-rand-transv-hi vector :inline :offset-assert 64)
|
|
(away-from-focal-pt vector :inline :offset-assert 48)
|
|
(away-from-rand-transv-xz-lo float :offset-assert 64)
|
|
(away-from-rand-transv-xz-hi float :offset-assert 68)
|
|
(away-from-rand-transv-y-lo float :offset-assert 72)
|
|
(away-from-rand-transv-y-hi float :offset-assert 76)
|
|
(hit-xz-reaction float :offset-assert 80)
|
|
(hit-y-reaction float :offset-assert 84)
|
|
(scale-rand-lo float :offset-assert 88)
|
|
(scale-rand-hi float :offset-assert 92)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
;; (define-extern debris-group-init-by-other function)
|
|
;; (define-extern debris-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; battle ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype battle-info (basic)
|
|
((id int8 :offset-assert 4)
|
|
(notice-spec uint64 :offset-assert 8)
|
|
(pick-logic int8 :offset-assert 16)
|
|
(notice-distance float :offset-assert 20)
|
|
(dont-spawn-initial-until-notice? symbol :offset-assert 24) ;; guessed by decompiler
|
|
(play-battle-music symbol :offset-assert 28) ;; guessed by decompiler
|
|
(min-battle-spawn-delay uint32 :offset-assert 32)
|
|
(max-battle-spawn-delay uint32 :offset-assert 36)
|
|
(min-spawner-notice-attack-delay uint32 :offset-assert 40)
|
|
(max-spawner-notice-attack-delay uint32 :offset-assert 44)
|
|
(spawner-blocked-by-player-xz float :offset-assert 48)
|
|
(spawner-blocked-by-collide-radius float :offset-assert 52)
|
|
(pick-spawner-max-dist float :offset-assert 56)
|
|
(max-count uint32 :offset-assert 60)
|
|
(desired-alive-count uint8 :offset-assert 64)
|
|
(spawner-collide-with collide-spec :offset-assert 68) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype battle-ally (structure)
|
|
((entity entity-actor :offset-assert 0) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype battle-ally-array (inline-array-class)
|
|
((data battle-ally :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype battle-breed (structure)
|
|
((breed-type type :offset-assert 0) ;; guessed by decompiler
|
|
(percent float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype battle-breed-array (inline-array-class)
|
|
((data battle-breed :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype battle-spawner (structure)
|
|
((flags uint64 :offset-assert 0) ;; battle-spawner-flags
|
|
(entity entity-actor :offset-assert 8) ;; guessed by decompiler
|
|
(breeds battle-breed-array :offset-assert 12) ;; guessed by decompiler
|
|
(creature-index int8 :offset-assert 16)
|
|
(ready-index int8 :offset-assert 17)
|
|
(attack-index int8 :offset-assert 18)
|
|
(mode uint8 :offset-assert 19)
|
|
(intro-path path-control :offset-assert 20) ;; guessed by decompiler
|
|
(notice-attack-delay uint32 :offset-assert 24)
|
|
(creature uint64 :offset-assert 32) ;; handle
|
|
(last-spawn-time uint64 :offset-assert 40) ;; time-frame
|
|
(noticed-attack-time uint64 :offset-assert 48) ;; time-frame
|
|
(attack-pos vector :inline :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype battle-spawner-array (inline-array-class)
|
|
((data battle-spawner :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype battle (process-drawable)
|
|
((info battle-info :offset-assert 200) ;; guessed by decompiler
|
|
(flags uint8 :offset-assert 204) ;; battle-flags
|
|
(spawn-initial-creatures? symbol :offset-assert 208) ;; guessed by decompiler
|
|
(next-spawn-delay uint32 :offset-assert 212)
|
|
(on-notice basic :offset-assert 216)
|
|
(on-hostile basic :offset-assert 220)
|
|
(on-beaten basic :offset-assert 224)
|
|
(max-count uint32 :offset-assert 228)
|
|
(count uint32 :offset-assert 232)
|
|
(die-count uint32 :offset-assert 236)
|
|
(stat-child-count uint16 :offset-assert 240)
|
|
(cant-spawn-time uint64 :offset-assert 248) ;; time-frame
|
|
(jammed-starting-time uint64 :offset-assert 256) ;; time-frame
|
|
(spawners battle-spawner-array :offset-assert 264) ;; guessed by decompiler
|
|
(allies battle-ally-array :offset-assert 268) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 53
|
|
:size-assert #x110
|
|
:flag-assert #x3500900110
|
|
;; field on-notice uses ~A with a signed load. field on-hostile uses ~A with a signed load. field on-beaten uses ~A with a signed load.
|
|
(:methods
|
|
(battle-method-21 () none) ;; 21 ;; (battle-state-21 () _type_ :state 21)
|
|
(battle-method-25 () none) ;; 25 ;; (spawner-blocked? (_type_ battle-spawner) symbol 25)
|
|
(battle-method-26 () none) ;; 26 ;; (spawner-blocked-by-collide? (_type_ battle-spawner) symbol 26)
|
|
(battle-method-27 () none) ;; 27 ;; (draw-battle-marks (_type_) none 27)
|
|
(battle-method-28 () none) ;; 28 ;; (initialize-enemy-lists (_type_) none 28)
|
|
(battle-method-29 () none) ;; 29 ;; (initialize-spawner-breeds (_type_ battle-spawner entity-actor) none 29)
|
|
(battle-method-30 () none) ;; 30 ;; (get-spawner-for-enemy (_type_ process) battle-spawner 30)
|
|
(battle-method-31 () none) ;; 31 ;; (initialize-ally (_type_ battle-ally entity-actor) none 31)
|
|
(battle-method-32 () none) ;; 32 ;; (initialize-spawner (_type_ battle-spawner entity-actor) none 32)
|
|
(battle-method-33 () none) ;; 33 ;; (initialize-battle (_type_) none 33)
|
|
(battle-method-34 () none) ;; 34 ;; (init-go (_type_) int 34)
|
|
(battle-method-35 () none) ;; 35 ;; (get-spawn-delay (_type_) int 35)
|
|
(battle-method-36 () none) ;; 36 ;; (get-best-spawner (_type_) battle-spawner 36)
|
|
(battle-method-37 () none) ;; 37 ;; (spawner-free? (_type_ battle-spawner) symbol 37)
|
|
(battle-method-38 () none) ;; 38 ;; (spawn-from-breed (_type_ battle-breed enemy-init-by-other-params) handle 38)
|
|
(battle-method-39 () none) ;; 39 ;; (spawn-from-spawner (_type_ battle-spawner symbol) none 39)
|
|
(battle-method-40 () none) ;; 40 ;; (spawn-initial-creatures (_type_) none 40)
|
|
(battle-method-41 () none) ;; 41 ;; (get-random-breed (_type_ battle-spawner) battle-breed 41)
|
|
(battle-method-42 () none) ;; 42 ;; (spawner-hit (_type_ battle-spawner process) symbol 42)
|
|
(battle-method-43 () none) ;; 43 ;; (spawner-try-jump (_type_ battle-spawner enemy) symbol 43)
|
|
(battle-method-44 () none) ;; 44 ;; (spawner-do-jump (_type_ battle-spawner) int 44)
|
|
(battle-method-45 () none) ;; 45 ;; (spawner-hittable? (_type_ battle-spawner) symbol 45)
|
|
(battle-method-46 () none) ;; 46 ;; (spawner-in-intro? (_type_ battle-spawner) symbol 46)
|
|
(battle-method-47 () none) ;; 47 ;; (set-battle-music (_type_) none 47)
|
|
(battle-method-48 () none) ;; 48 ;; (unset-battle-music (_type_) none 48)
|
|
(battle-method-49 () none) ;; 49 ;; (update-allies-list (_type_) int 49)
|
|
(battle-method-50 () none) ;; 50 ;; (beaten? (_type_) symbol 50)
|
|
(battle-method-51 () none) ;; 51 ;; (spawner-active? (_type_ battle-spawner symbol) symbol 51)
|
|
(battle-method-52 () none) ;; 52 ;; (spawner-active-count (_type_) int 52)
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
notice ;; 22, old: (notice () _type_ :state 22)
|
|
hostile ;; 23, old: (hostile () _type_ :state 23)
|
|
beaten ;; 24, old: (beaten () _type_ :state 24)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *battles* array) ;; (array battle-info)
|
|
;; (define-extern battle-event-handler function) ;; (function process int symbol event-message-block object :behavior battle)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyport-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype port-board-vent (bouncer)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xd8
|
|
:flag-assert #x1b006000d8
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spt-birth-func-brightness-daxter-crush-dust function)
|
|
;; (define-extern *range-dax-sign-explo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-dax-sign-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-dax-sign-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-dax-sign-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-dax-sign-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-dax-sign-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-dax-sign-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-daxter-sign-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-dax-sign-explo-color* curve-color-fast)
|
|
;; (define-extern *range-dax-sign-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-dax-sign-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-dax-sign-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-dax-sign-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-dax-sign-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-dax-sign-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-daxter-sign-explosion-texture-curve-settings* object)
|
|
;; (define-extern *range-fma-barrier-explo-big-color* curve-color-fast)
|
|
;; (define-extern *range-fma-barrier-explo-big-alpha* curve2d-fast)
|
|
;; (define-extern *range-fma-barrier-explo-big-scale-x* curve2d-fast)
|
|
;; (define-extern *range-fma-barrier-explo-big-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-fma-barrier-explo-big-alpha* curve2d-fast)
|
|
;; (define-extern *curve-fma-barrier-explo-big-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-fma-barrier-explo-big-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fma-barrier-explosion-big-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; spyder ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype spyder-shot (metalhead-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x210
|
|
:flag-assert #x2901900210
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spyder (nav-enemy)
|
|
((los los-control :inline :offset-assert 624)
|
|
(joint joint-mod-blend-world :inline :offset-assert 800) ;; joint-mod
|
|
(start-pos vector :inline :offset-assert 928)
|
|
(focus-pos vector :inline :offset-assert 352)
|
|
(face-pos vector :inline :offset-assert 960)
|
|
(my-up-vector vector :inline :offset-assert 976)
|
|
(status-flags uint64 :offset-assert 992) ;; spyder-flags
|
|
(change-dir-timer uint64 :offset-assert 1000) ;; time-frame
|
|
(fire-info vector 2 :offset-assert 1008) ;; guessed by decompiler
|
|
(joint-ik joint-mod-ik 4 :offset-assert 1040) ;; guessed by decompiler
|
|
(delta-y-ik float 4 :offset-assert 1056) ;; guessed by decompiler
|
|
(predator-effect? symbol :offset-assert 1072) ;; guessed by decompiler
|
|
(shock-effect-time uint64 :offset-assert 1080) ;; time-frame
|
|
(shock-effect-end uint64 :offset-assert 1088) ;; time-frame
|
|
(fade float :offset-assert 1096)
|
|
(dest-fade float :offset-assert 1100)
|
|
)
|
|
:method-count-assert 198
|
|
:size-assert #x450
|
|
:flag-assert #xc603d00450
|
|
(:methods
|
|
(spyder-method-192 () none) ;; 192
|
|
(spyder-method-193 () none) ;; 193
|
|
(spyder-method-194 () none) ;; 194
|
|
(spyder-method-195 () none) ;; 195
|
|
(spyder-method-196 () none) ;; 196
|
|
(spyder-method-197 () none) ;; 197
|
|
)
|
|
(:state-methods
|
|
notice ;; 35
|
|
active ;; 34
|
|
hostile ;; 38
|
|
attack ;; 190
|
|
backup ;; 191
|
|
knocked ;; 31
|
|
victory ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *spyder-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern spyder-travel-post function) ;; (function none :behavior spyder)
|
|
;; (define-extern spyder-face-player-post function) ;; (function none :behavior spyder)
|
|
;; (define-extern *spyder-ik-limb-setup* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mine-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-explo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-bomb-train-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-explo-color* curve-color-fast)
|
|
;; (define-extern *range-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-bomb-train-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-network-adjacency (structure)
|
|
((index int32 :offset-assert 0)
|
|
(dist float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-network-adjacency-array (inline-array-class)
|
|
((data nav-network-adjacency :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype list-node (structure)
|
|
((next list-node :offset-assert 0)
|
|
(prev list-node :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-network-path-node (list-node)
|
|
((row-index int32 :offset-assert 8)
|
|
(status net-path-node-status :offset-assert 12)
|
|
(parent nav-network-path-node :offset-assert 16)
|
|
(cost-to-start float :offset-assert 20)
|
|
(cost-to-end float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
;; field net-path-node-status is likely a value type.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-network-info (structure)
|
|
((path-node nav-network-path-node :inline :offset-assert 0)
|
|
(pos vector :inline :offset-assert 32)
|
|
(index int32 :offset-assert 48)
|
|
(sub-graph int32 :offset-assert 52)
|
|
(count int32 :offset-assert 56)
|
|
(adjacency (inline-array nav-network-adjacency) :offset-assert 60) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-network-info-array (inline-array-class)
|
|
((data nav-network-info :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-network-edge (structure)
|
|
((start-index int32 :offset-assert 0)
|
|
(end-index int32 :offset-assert 4)
|
|
(radius float :offset-assert 8)
|
|
(sub-graph int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-nav-sphere (list-node)
|
|
((sphere sphere :inline :offset-assert 16)
|
|
(handle uint64 :offset-assert 32) ;; handle
|
|
(timer uint64 :offset-assert 40) ;; time-frame
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-nav-path-segment (list-node)
|
|
((curve-matrix matrix :inline :offset-assert 16)
|
|
(pos-index float 2 :offset-assert 80) ;; guessed by decompiler
|
|
(dist float :offset-assert 88)
|
|
(du float :offset-assert 92)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x60
|
|
:flag-assert #xa00000060
|
|
(:methods
|
|
(hover-nav-path-segment-method-9 () none) ;; 9 ;; (hover-nav-path-segment-method-9 (_type_ float) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-nav-path-info (structure)
|
|
((segment-list hover-nav-path-segment :offset-assert 0)
|
|
(tail-segment hover-nav-path-segment :offset-assert 4)
|
|
(curr-segment hover-nav-path-segment :offset-assert 8)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xc
|
|
:flag-assert #xa0000000c
|
|
(:methods
|
|
(hover-nav-path-info-method-9 () none) ;; 9 ;; (hover-nav-path-info-method-9 (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-network-data (structure)
|
|
((node-array basic :offset-assert 0)
|
|
(edge-array basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype path-index-array (inline-array-class)
|
|
((data hover-nav-path-info :dynamic :offset-assert 16) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-network (basic)
|
|
((network (array nav-network-info) :offset-assert 4) ;; guessed by decompiler
|
|
(edge basic :offset-assert 8)
|
|
(control-handle uint64 :offset-assert 16) ;; handle
|
|
(list-table list-node 5 :offset-assert 32) ;; guessed by decompiler
|
|
(open-list nav-network-path-node :offset-assert 32)
|
|
(closed-list nav-network-path-node :offset-assert 36)
|
|
(sphere-list hover-nav-sphere :offset-assert 44)
|
|
(free-segment-list hover-nav-path-segment :offset-assert 40)
|
|
(free-sphere-list hover-nav-sphere :offset-assert 48)
|
|
(segment-pool (pointer hover-nav-path-segment) :offset-assert 52) ;; guessed by decompiler
|
|
(sphere-pool (pointer hover-nav-sphere) :offset-assert 56) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x3c
|
|
:flag-assert #x260000003c
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(nav-network-method-9 () none) ;; 9 ;; (nav-network-method-9 (_type_) none 9)
|
|
(nav-network-method-10 () none) ;; 10 ;; (nav-network-method-10 (_type_ level (array nav-network-info)) none 10)
|
|
(nav-network-method-11 () none) ;; 11 ;; (nav-network-method-11 (_type_) none 11)
|
|
(nav-network-method-12 () none) ;; 12 ;; (nav-network-method-12 (_type_) none 12)
|
|
(nav-network-method-13 () none) ;; 13 ;; (nav-network-method-13 (_type_ int nav-network-path-node) none 13)
|
|
(nav-network-method-14 () none) ;; 14 ;; (nav-network-method-14 (_type_ int nav-network-path-node) object 14)
|
|
(nav-network-method-15 () none) ;; 15 ;; (nav-network-method-15 (_type_ nav-network-path-node) object 15)
|
|
(nav-network-method-16 () none) ;; 16 ;; (nav-network-method-16 (_type_ nav-network-path-node) none 16)
|
|
(nav-network-method-17 () none) ;; 17 ;; (nav-network-method-17 (_type_) nav-network-path-node 17)
|
|
(nav-network-method-18 () none) ;; 18 ;; (nav-network-method-18 (_type_ nav-network-path-node) none 18)
|
|
(nav-network-method-19 () none) ;; 19 ;; (nav-network-method-19 (_type_ nav-network-path-node) none 19)
|
|
(nav-network-method-20 () none) ;; 20 ;; (nav-network-method-20 (_type_ nav-network-path-node vector) none 20)
|
|
(nav-network-method-21 () none) ;; 21 ;; (nav-network-method-21 (_type_ object int int) none 21)
|
|
(nav-network-method-22 () none) ;; 22 ;; (nav-network-method-22 (_type_ hover-nav-path-info vector vector int int) hover-nav-path-segment 22)
|
|
(nav-network-method-23 () none) ;; 23 ;; (nav-network-method-23 (_type_ hover-nav-path-info) none 23)
|
|
(nav-network-method-24 () none) ;; 24 ;; (nav-network-method-24 (_type_ hover-nav-path-info int int int) symbol 24)
|
|
(nav-network-method-25 () none) ;; 25 ;; (nav-network-method-25 (_type_ process collide-prim-core) none 25)
|
|
(nav-network-method-26 () none) ;; 26 ;; (nav-network-method-26 (_type_ vector process vector vector float) vector 26)
|
|
(nav-network-method-27 () none) ;; 27 ;; (nav-network-method-27 (_type_) none 27)
|
|
(nav-network-method-28 () none) ;; 28 ;; (nav-network-method-28 (_type_) none 28)
|
|
(nav-network-method-29 () none) ;; 29 ;; (nav-network-method-29 (_type_) symbol 29)
|
|
(nav-network-method-30 () none) ;; 30 ;; (get-network (_type_) (array nav-network-info) 30)
|
|
(nav-network-method-31 () none) ;; 31 ;; (nav-network-method-31 (_type_ bounding-box) none 31)
|
|
(nav-network-method-32 () none) ;; 32 ;; (nav-network-method-32 (_type_ string) none 32)
|
|
(nav-network-method-33 () none) ;; 33
|
|
(nav-network-method-34 () none) ;; 34
|
|
(nav-network-method-35 () none) ;; 35
|
|
(nav-network-method-36 () none) ;; 36
|
|
(nav-network-method-37 () none) ;; 37
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-nav-params (structure)
|
|
((max-speed float :offset-assert 0)
|
|
(max-acceleration float :offset-assert 4)
|
|
(max-rotation-rate float :offset-assert 8)
|
|
(friction float :offset-assert 12)
|
|
(nav-collide-prim-index int32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-fixed-path-info (structure)
|
|
((path basic :offset-assert 0)
|
|
(start-index int32 :offset-assert 4)
|
|
(end-index int32 :offset-assert 8)
|
|
(current-index int32 :offset-assert 12)
|
|
(step int32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-nav-control (basic)
|
|
((root collide-shape-moving :offset-assert 4) ;; guessed by decompiler
|
|
(fixed-path-info hover-fixed-path-info :inline :offset-assert 8)
|
|
(path-info hover-nav-path-info :inline :offset-assert 28)
|
|
(transvv vector :inline :offset-assert 48)
|
|
(dest-pos vector :inline :offset-assert 64)
|
|
(dest-vel vector :inline :offset-assert 80)
|
|
(dest-move-dir vector :inline :offset-assert 96)
|
|
(dest-offset vector :inline :offset-assert 112)
|
|
(move-dir vector :inline :offset-assert 128)
|
|
(nav-collide-impulse vector :inline :offset-assert 144)
|
|
(nav nav-network :offset-assert 160) ;; guessed by decompiler
|
|
(flags uint16 :offset-assert 164) ;; hover-nav-flags
|
|
(params hover-nav-params :offset-assert 168)
|
|
(path-timer uint64 :offset-assert 176) ;; time-frame
|
|
(sub-graph int32 :offset-assert 184)
|
|
(nav-collide-impulse-len float :offset-assert 188)
|
|
(dest-speed float :offset-assert 192)
|
|
(local-dist float :offset-assert 196)
|
|
(speed float :offset-assert 200)
|
|
(max-los-speed float :offset-assert 204)
|
|
(target-speed float :offset-assert 208)
|
|
(target-acceleration float :offset-assert 212)
|
|
(u-param float :offset-assert 216)
|
|
(speed-dest float :offset-assert 220)
|
|
(curr-dest-pt int32 :offset-assert 224)
|
|
(max-speed-multiplier float :offset-assert 228)
|
|
(max-acceleration-multiplier float :offset-assert 232)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #xec
|
|
:flag-assert #x23000000ec
|
|
(:methods
|
|
;; (new (symbol type process collide-shape-moving hover-nav-params) _type_ 0)
|
|
(hover-nav-control-method-9 () none) ;; 9 ;; (hover-nav-control-method-9 (_type_) none 9)
|
|
(hover-nav-control-method-10 () none) ;; 10 ;; (hover-nav-control-method-10 (_type_ vector vector vector) none 10)
|
|
(hover-nav-control-method-11 () none) ;; 11 ;; (hover-nav-control-method-11 (_type_ vector) none 11)
|
|
(hover-nav-control-method-12 () none) ;; 12 ;; (hover-nav-control-method-12 (_type_) none 12)
|
|
(hover-nav-control-method-13 () none) ;; 13 ;; (hover-nav-control-method-13 (_type_) none 13)
|
|
(hover-nav-control-method-14 () none) ;; 14 ;; (hover-nav-control-method-14 (_type_ float float) none 14)
|
|
(hover-nav-control-method-15 () none) ;; 15 ;; (hover-nav-control-method-15 (_type_ vector) none 15)
|
|
(hover-nav-control-method-16 () none) ;; 16 ;; (hover-nav-control-method-16 (_type_ vector) vector 16)
|
|
(hover-nav-control-method-17 () none) ;; 17 ;; (hover-nav-control-method-17 (_type_) collide-prim-core 17)
|
|
(hover-nav-control-method-18 () none) ;; 18 ;; (hover-nav-control-method-18 (_type_ path-control int int) none 18)
|
|
(hover-nav-control-method-19 () none) ;; 19 ;; (hover-nav-control-method-19 (_type_ (inline-array vector) int) none 19)
|
|
(hover-nav-control-method-20 () none) ;; 20 ;; (hover-nav-control-method-20 (_type_) none 20)
|
|
(hover-nav-control-method-21 () none) ;; 21 ;; (hover-nav-control-method-21 (_type_) none 21)
|
|
(hover-nav-control-method-22 () none) ;; 22 ;; (hover-nav-control-method-22 (_type_) hover-nav-path-segment 22)
|
|
(hover-nav-control-method-23 () none) ;; 23 ;; (hover-nav-control-method-23 (_type_) object 23)
|
|
(hover-nav-control-method-24 () none) ;; 24 ;; (hover-nav-control-method-24 (_type_) none 24)
|
|
(hover-nav-control-method-25 () none) ;; 25 ;; (hover-nav-control-method-25 (_type_) none 25)
|
|
(hover-nav-control-method-26 () none) ;; 26 ;; (hover-nav-control-method-26 (_type_ vector vector float) symbol 26)
|
|
(hover-nav-control-method-27 () none) ;; 27 ;; (hover-nav-control-method-27 (_type_ vector vector) int 27)
|
|
(hover-nav-control-method-28 () none) ;; 28 ;; (hover-nav-control-method-28 (_type_ vector vector) none 28)
|
|
(hover-nav-control-method-29 () none) ;; 29 ;; (hover-nav-control-method-29 (_type_ vector) none 29)
|
|
(hover-nav-control-method-30 () none) ;; 30 ;; (hover-nav-control-method-30 (_type_) float 30)
|
|
(hover-nav-control-method-31 () none) ;; 31 ;; (hover-nav-control-method-31 (_type_) float 31)
|
|
(hover-nav-control-method-32 () none) ;; 32
|
|
(hover-nav-control-method-33 () none) ;; 33
|
|
(hover-nav-control-method-34 () none) ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *debug-hover* object) ;; symbol
|
|
;; (define-extern *dummy-adjacency* object)
|
|
;; (define-extern *hover-nav-time-offset* object) ;; int
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-templea ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *templea-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; intro-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-intro-dust-color* curve-color-fast)
|
|
;; (define-extern *range-intro-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-intro-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-intro-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-intro-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-intro-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-intro-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-drop-dust-trail-curve-settings* object)
|
|
;; (define-extern *part-drop-dust-landing-curve-settings* object)
|
|
;; (define-extern *part-drop-dust-takeoff-curve-settings* object)
|
|
;; (define-extern *curve-intro-dust-cloud-alpha* curve2d-fast)
|
|
;; (define-extern *curve-intro-dust-cloud-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-intro-dust-cloud-scale-y* curve2d-fast)
|
|
;; (define-extern *part-drop-dust-cloud-curve-settings* object)
|
|
;; (define-extern *range-intro-pecker-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-intro-pecker-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-intro-pecker-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-intro-pecker-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-drop-pecker-dustoff-curve-settings* object)
|
|
;; (define-extern birth-func-dust-inherit-scaler function)
|
|
;; (define-extern *range-color-desert-impact-dust* curve-color-fast)
|
|
;; (define-extern *range-alpha-desert-impact-dust* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-impact-dust-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-impact-dust-y* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-impact-dust* curve2d-fast)
|
|
;; (define-extern *curve-desert-impact-dust-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-impact-dust-y* curve2d-fast)
|
|
;; (define-extern *part-desert-impact-dust-curve-settings* object)
|
|
;; (define-extern *range-alpha-desert-impact-dust-blow* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-impact-dust-blow-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-impact-dust-blow-y* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-impact-dust-blow* curve2d-fast)
|
|
;; (define-extern *curve-desert-impact-dust-blow-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-impact-dust-blow-y* curve2d-fast)
|
|
;; (define-extern *part-desert-impact-dust-blow-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-enemy-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hover-enemy-info (structure)
|
|
((fly-forward-anim int32 :offset-assert 0)
|
|
(fly-backward-anim int32 :offset-assert 4)
|
|
(fly-left-anim int32 :offset-assert 8)
|
|
(fly-right-anim int32 :offset-assert 12)
|
|
(shoot-anim int32 :offset-assert 16)
|
|
(main-joint int32 :offset-assert 20)
|
|
(gun-base int32 :offset-assert 24)
|
|
(engine-left int32 :offset-assert 28)
|
|
(engine-right int32 :offset-assert 32)
|
|
(thrust-rotate-left float :offset-assert 36)
|
|
(thrust-rotate-right float :offset-assert 40)
|
|
(hover-y-offset float :offset-assert 44)
|
|
(hover-xz-offset float :offset-assert 48)
|
|
(use-flying-death basic :offset-assert 52)
|
|
(fly-x-anim-seek float :offset-assert 56)
|
|
(fly-z-anim-seek float :offset-assert 60)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-enemy (enemy)
|
|
((los los-control :inline :offset-assert 560)
|
|
(main-joint-movement UNKNOWN 3 :offset-assert 736)
|
|
(rotation-vec vector :inline :offset-assert 784)
|
|
(dest-pos vector :inline :offset-assert 800)
|
|
(offset vector :inline :offset-assert 816)
|
|
(surface-normal vector :inline :offset-assert 832)
|
|
(local-dir vector :inline :offset-assert 848)
|
|
(hover hover-nav-control :offset-assert 864) ;; guessed by decompiler
|
|
(hover-info hover-enemy-info :offset-assert 868)
|
|
(formation-entity entity :offset-assert 872) ;; guessed by decompiler
|
|
(fly-anim-speed float :offset-assert 876)
|
|
(restart-fly-anims symbol :offset-assert 880) ;; guessed by decompiler
|
|
(thrust float 2 :offset-assert 884) ;; guessed by decompiler
|
|
(scale float :offset-assert 892)
|
|
(scale-timer uint64 :offset-assert 896)
|
|
(hover-id int32 :offset-assert 904)
|
|
(hit-surface? symbol :offset-assert 908) ;; guessed by decompiler
|
|
(knocked-start-level float :offset-assert 912)
|
|
(knocked-fall-dist float :offset-assert 916)
|
|
(flying-death-anim int32 :offset-assert 920)
|
|
(flying-death-transv vector :inline :offset-assert 928)
|
|
(flying-death-engine int32 :offset-assert 944)
|
|
(flying-death-thrust-rotate float :offset-assert 948)
|
|
(flying-death-spin float :offset-assert 952)
|
|
(flying-death-spin-dest float :offset-assert 956)
|
|
(flying-death-spin-axis vector :inline :offset-assert 960)
|
|
)
|
|
:method-count-assert 177
|
|
:size-assert #x3d0
|
|
:flag-assert #xb1035003d0
|
|
(:methods
|
|
(hover-enemy-method-155 () none) ;; 155 ;; (hover-enemy-method-155 (_type_) none 155)
|
|
(hover-enemy-method-156 () none) ;; 156
|
|
(hover-enemy-method-157 () none) ;; 157
|
|
(hover-enemy-method-158 () none) ;; 158
|
|
(hover-enemy-method-159 () none) ;; 159
|
|
(hover-enemy-method-160 () none) ;; 160
|
|
(hover-enemy-method-161 () none) ;; 161
|
|
(hover-enemy-method-162 () none) ;; 162
|
|
(hover-enemy-method-163 () none) ;; 163
|
|
(hover-enemy-method-164 () none) ;; 164
|
|
(hover-enemy-method-165 () none) ;; 165
|
|
(hover-enemy-method-166 () none) ;; 166
|
|
(hover-enemy-method-167 () none) ;; 167
|
|
(hover-enemy-method-168 () none) ;; 168
|
|
(hover-enemy-method-169 () none) ;; 169
|
|
(hover-enemy-method-170 () none) ;; 170
|
|
(hover-enemy-method-171 () none) ;; 171
|
|
(hover-enemy-method-172 () none) ;; 172
|
|
(hover-enemy-method-173 () none) ;; 173
|
|
(hover-enemy-method-174 () none) ;; 174
|
|
(hover-enemy-method-175 () none) ;; 175
|
|
(hover-enemy-method-176 () none) ;; 176
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-network-control (process)
|
|
((nav-network nav-network :offset-assert 128) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x84
|
|
:flag-assert #xf00100084
|
|
(:state-methods
|
|
idle ;; 14, old: (idle () _type_ :state 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern nav-network-control-init-by-other function) ;; (function nav-network level none :behavior nav-network-control)
|
|
;; (define-extern detect-loop function)
|
|
;; (define-extern list-contains function)
|
|
;; (define-extern *nav-network* object) ;; nav-network
|
|
;; (define-extern hover-bounce-reaction function) ;; (function control-info collide-query vector vector collide-status)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-edit ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hover-nav-bsp-point (list-node)
|
|
((index int32 :offset-assert 8)
|
|
(pos vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-nav-bsp-node (structure)
|
|
((split-plane vector :inline :offset-assert 0)
|
|
(point-list hover-nav-bsp-point :offset-assert 16)
|
|
(left hover-nav-bsp-node :offset-assert 20)
|
|
(right hover-nav-bsp-node :offset-assert 24)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x1c
|
|
:flag-assert #xb0000001c
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(hover-nav-bsp-node-method-9 () none) ;; 9 ;; (hover-nav-bsp-node-method-9 (_type_) none 9)
|
|
(hover-nav-bsp-node-method-10 () none) ;; 10 ;; (hover-nav-bsp-node-method-10 (_type_ int) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hover-nav-bsp (structure)
|
|
((root hover-nav-bsp-node :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern probe-for-clear-collision? function) ;; (function vector vector symbol)
|
|
;; (define-extern hover-nav-graph-process-points function) ;; (function none)
|
|
;; (define-extern hover-nav-graph-output function) ;; (function symbol)
|
|
;; (define-extern *axes-table* array) ;; (array vector)
|
|
;; (define-extern *hover-bsp* object) ;; hover-nav-bsp
|
|
;; (define-extern hover-nav-graph-output-bsp function) ;; (function hover-nav-bsp)
|
|
;; (define-extern hover-nav-network-build-bsp function) ;; (function (array hover-nav-bsp-point) hover-nav-bsp)
|
|
;; (define-extern hover-nav-bsp-output function) ;; (function hover-nav-bsp none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; temple-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tpl-bouncer (bouncer)
|
|
()
|
|
:method-count-assert 28
|
|
:size-assert #xd8
|
|
:flag-assert #x1c006000d8
|
|
(:state-methods
|
|
idle ;; 20
|
|
fire ;; 21
|
|
broken ;; 27
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-outer-airlock-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-mardoor (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-temple-defend (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-temple-oracle (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-temple-oracle-powerup (task-manager)
|
|
((arrow-h uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf8
|
|
:flag-assert #x20008000f8
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-lightjak-training (task-manager)
|
|
((gui-id uint32 :offset-assert 240)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xf4
|
|
:flag-assert #x21008000f4
|
|
(:methods
|
|
(task-manager-lightjak-training-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-lightjak-training-freeze (task-manager-lightjak-training)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #xf4
|
|
:flag-assert #x21008000f4
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-lightjak-training-swoop (task-manager-lightjak-training)
|
|
((learned-to-flap? basic :offset-assert 244)
|
|
(flap-count int32 :offset-assert 248)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xfc
|
|
:flag-assert #x21008000fc
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-holo-eye (process-drawable)
|
|
((eyeball-jmod joint-mod-set-world-no-trans :inline :offset-assert 204)
|
|
(other-eyeball-jmod joint-mod-set-world :inline :offset-assert 268)
|
|
(next-blink-time uint64 :offset-assert 332)
|
|
(trigger-radius float :offset-assert 340)
|
|
(idle-clock uint64 :offset-assert 348)
|
|
(actor-group uint32 :offset-assert 356)
|
|
(actor-group-count int32 :offset-assert 360)
|
|
(triggered? basic :offset-assert 364)
|
|
(untriggered? basic :offset-assert 368)
|
|
(kill-quat quaternion :inline :offset-assert 380)
|
|
(kill-angle float :offset-assert 396)
|
|
(kill-speed float :offset-assert 400)
|
|
(init-trans vector :inline :offset-assert 412)
|
|
(perm-part uint64 :offset-assert 428)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x1b8
|
|
:flag-assert #x19014001b8
|
|
(:methods
|
|
(tpl-holo-eye-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
alert ;; 21
|
|
die ;; 22
|
|
die-fast ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-spike-trap (process-drawable)
|
|
((was-up basic :offset-assert 200)
|
|
(no-collision-timer uint64 :offset-assert 208)
|
|
(attack-id int32 :offset-assert 216)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xdc
|
|
:flag-assert #x16006000dc
|
|
(:state-methods
|
|
idle-down ;; 20
|
|
idle-up ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-elec-swing-pole (swingpole)
|
|
((y-start float :offset-assert 284)
|
|
(y-end float :offset-assert 288)
|
|
(electrify basic :offset-assert 292)
|
|
(lightning UNKNOWN 4 :offset-assert 296)
|
|
(y-disable float :offset-assert 312)
|
|
(sound-id uint32 :offset-assert 316)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x140
|
|
:flag-assert #x1a00c00140
|
|
(:state-methods
|
|
idle ;; 20
|
|
goup ;; 25
|
|
active ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-spindle (process-drawable)
|
|
((init-quat quaternion :inline :offset-assert 208)
|
|
(init-quat2 quaternion :inline :offset-assert 224)
|
|
(rot-angle float :offset-assert 240)
|
|
(shudder-angle float :offset-assert 244)
|
|
(cycle-time float :offset-assert 248)
|
|
(cycle-offset float :offset-assert 252)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x100
|
|
:flag-assert #x1600800100
|
|
(:state-methods
|
|
idle ;; 20
|
|
idle-slow ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-fan-two (process-drawable)
|
|
((quat quaternion :inline :offset-assert 208)
|
|
(cycle-time float :offset-assert 224)
|
|
(cycle-offset float :offset-assert 228)
|
|
(start-timef float :offset-assert 232)
|
|
(next-sound float :offset-assert 236)
|
|
(last-sound float :offset-assert 240)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xf4
|
|
:flag-assert #x15008000f4
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-fan-three (process-drawable)
|
|
((quat quaternion :inline :offset-assert 208)
|
|
(cycle-time float :offset-assert 224)
|
|
(cycle-offset float :offset-assert 228)
|
|
(start-timef float :offset-assert 232)
|
|
(next-sound float :offset-assert 236)
|
|
(last-sound float :offset-assert 240)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xf4
|
|
:flag-assert #x15008000f4
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-break-alcove (process-drawable)
|
|
((alt-actor basic :offset-assert 200)
|
|
(extra-id uint32 :offset-assert 204)
|
|
(perm uint32 :offset-assert 208)
|
|
(part-explode basic :offset-assert 212)
|
|
(spawn-part basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xdc
|
|
:flag-assert #x17006000dc
|
|
(:state-methods
|
|
idle ;; 20
|
|
closed ;; 21
|
|
die-fast ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-break-door-a (process-drawable)
|
|
((alt-actor basic :offset-assert 200)
|
|
(extra-id uint32 :offset-assert 204)
|
|
(perm uint32 :offset-assert 208)
|
|
(part-explode basic :offset-assert 212)
|
|
(spawn-part basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xdc
|
|
:flag-assert #x17006000dc
|
|
(:state-methods
|
|
idle ;; 20
|
|
closed ;; 21
|
|
die-fast ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern templea-login function)
|
|
;; (define-extern templea-logout function)
|
|
;; (define-extern templea-activate function)
|
|
;; (define-extern sparticle-holo-halo0 function)
|
|
;; (define-extern sparticle-holo-halo1 function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; waspala-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype water-anim-waspala (water-anim)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype waspala-paddle-wheel (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:methods
|
|
(waspala-paddle-wheel-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype waspala-paddle-wheel-a (waspala-paddle-wheel)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype waspala-paddle-wheel-b (waspala-paddle-wheel)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype waspala-windmill (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-throne-gun-training (task-manager)
|
|
((gui-id uint32 :offset-assert 240)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xf4
|
|
:flag-assert #x21008000f4
|
|
(:methods
|
|
(task-manager-throne-gun-training-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype waspala-blocker (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern ripple-for-water-anim-waspala ripple-wave-set)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flamer-hover ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flamer-hover (hover-enemy)
|
|
((shot-trajectory trajectory :inline :offset-assert 976)
|
|
(last-fire-time uint64 :offset-assert 1016)
|
|
(sync-off uint32 :offset-assert 1024)
|
|
(flit-joint joint-mod-set-local :inline :offset-assert 1040)
|
|
(flit-angle float :offset-assert 1104)
|
|
(flit-timer uint64 :offset-assert 1112)
|
|
(sound-volume float :offset-assert 1120)
|
|
(path-u float :offset-assert 1124)
|
|
)
|
|
:method-count-assert 178
|
|
:size-assert #x468
|
|
:flag-assert #xb203f00468
|
|
(:state-methods
|
|
ambush ;; 47
|
|
hostile ;; 38
|
|
flying-death-explode ;; 158
|
|
attack ;; 177
|
|
knocked-recover ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *flamer-hover-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *flamer-hover-enemy-info* enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; assault-task ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ammo-special-info (structure)
|
|
((ammo-type int32 :offset-assert 0)
|
|
(gun-type int32 :offset-assert 4)
|
|
(end-lock-time uint64 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-city-port-assault (task-manager)
|
|
((script-command assault-cmd-context :inline :offset-assert 240)
|
|
(door-handle uint64 :offset-assert 312)
|
|
(current-room assault-room :offset-assert 320)
|
|
(current-room-index int8 :offset-assert 324)
|
|
(h-player-controller uint64 :offset-assert 328)
|
|
(spawners UNKNOWN 12 :offset-assert 336)
|
|
(original-cam-point vector :inline :offset-assert 1296)
|
|
(original-cam-quat quaternion :inline :offset-assert 1312)
|
|
(ammo-special ammo-special-info :inline :offset-assert 1328)
|
|
(torn-h uint64 :offset-assert 1344)
|
|
(next-powerup-spawn-time uint64 :offset-assert 1352)
|
|
(final-bombbot? basic :offset-assert 1360)
|
|
(room-override-index int8 :offset-assert 1364)
|
|
(bombbot-dead? basic :offset-assert 1368)
|
|
(cam-pan-sound uint32 :offset-assert 1372)
|
|
)
|
|
:method-count-assert 53
|
|
:size-assert #x560
|
|
:flag-assert #x3504e00560
|
|
(:methods
|
|
(task-manager-city-port-assault-method-36 () none) ;; 36
|
|
(task-manager-city-port-assault-method-37 () none) ;; 37
|
|
(task-manager-city-port-assault-method-38 () none) ;; 38
|
|
(task-manager-city-port-assault-method-39 () none) ;; 39
|
|
(task-manager-city-port-assault-method-40 () none) ;; 40
|
|
(task-manager-city-port-assault-method-41 () none) ;; 41
|
|
(task-manager-city-port-assault-method-42 () none) ;; 42
|
|
(task-manager-city-port-assault-method-43 () none) ;; 43
|
|
(task-manager-city-port-assault-method-44 () none) ;; 44
|
|
(task-manager-city-port-assault-method-45 () none) ;; 45
|
|
(task-manager-city-port-assault-method-46 () none) ;; 46
|
|
(task-manager-city-port-assault-method-47 () none) ;; 47
|
|
(task-manager-city-port-assault-method-48 () none) ;; 48
|
|
(task-manager-city-port-assault-method-49 () none) ;; 49
|
|
(task-manager-city-port-assault-method-50 () none) ;; 50
|
|
(task-manager-city-port-assault-method-51 () none) ;; 51
|
|
(task-manager-city-port-assault-method-52 () none) ;; 52
|
|
)
|
|
(:state-methods
|
|
transition ;; 32
|
|
player-quickstart ;; 35
|
|
player-entrance ;; 34
|
|
combat ;; 33
|
|
active ;; 15
|
|
wait ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-player-controller (player-controller)
|
|
((collision assault-room-collision :offset-assert 272)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x114
|
|
:flag-assert #x2500a00114
|
|
(:methods
|
|
(assault-player-controller-method-36 () none) ;; 36
|
|
)
|
|
(:state-methods
|
|
clip-to-nav-mesh ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-squad-control (basic)
|
|
((door-index int16 :offset-assert 4)
|
|
(spawn-records basic :offset-assert 8)
|
|
(next-spawn-index int16 :offset-assert 12)
|
|
(door-pos vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x20
|
|
:flag-assert #xe00000020
|
|
(:methods
|
|
(assault-squad-control-method-9 () none) ;; 9
|
|
(assault-squad-control-method-10 () none) ;; 10
|
|
(assault-squad-control-method-11 () none) ;; 11
|
|
(assault-squad-control-method-12 () none) ;; 12
|
|
(assault-squad-control-method-13 () none) ;; 13
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *port-assault-blur-curve* object)
|
|
;; (define-extern compute-player-ammo function)
|
|
;; (define-extern lctypalt-login function)
|
|
;; (define-extern lctypalt-logout function)
|
|
;; (define-extern skip-to-room function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; neon-baron-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype neon-baron (process)
|
|
((flags uint64 :offset-assert 128) ;; int64
|
|
(master-enable uint64 :offset-assert 136) ;; int64
|
|
(mode uint64 :offset-assert 144) ;; int64
|
|
(sign (array object) :offset-assert 152) ;; guessed by decompiler
|
|
(parts sparticle-launch-control 1 :offset-assert 156) ;; guessed by decompiler
|
|
(state-time uint64 :offset-assert 160) ;; time-frame
|
|
(mat matrix :inline :offset-assert 176)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #xf0
|
|
:flag-assert #x11007000f0
|
|
(:methods
|
|
(neon-baron-method-15 () none) ;; 15 ;; (spawn-parts (_type_) none 15)
|
|
(neon-baron-method-16 () none) ;; 16 ;; (update-mode (_type_) none 16)
|
|
)
|
|
(:state-methods
|
|
idle ;; 14, old: (idle () _type_ :state 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *baron-neon-skull* array) ;; (array object)
|
|
;; (define-extern *city-baron-group-ids* array) ;; (array int32)
|
|
;; (define-extern *neon-baron-flashing-acc* object) ;; (pointer uint32)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; jump-pad ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype jump-pad (bouncer)
|
|
((fan-quat quaternion :inline :offset-assert 224)
|
|
(rot-vel float :offset-assert 240)
|
|
(fan-loop-sound-id uint32 :offset-assert 244)
|
|
(fan-loop-sound basic :offset-assert 248)
|
|
(jump-sound basic :offset-assert 252)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x100
|
|
:flag-assert #x1e00800100
|
|
(:methods
|
|
(jump-pad-method-27 () none) ;; 27
|
|
(jump-pad-method-28 () none) ;; 28
|
|
(jump-pad-method-29 () none) ;; 29
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
fire ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern jump-pad-joint-fan function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-sewo ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sewo-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wlander-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wlander-anim-info (structure)
|
|
((anim-index UNKNOWN 2 :offset-assert 0)
|
|
(anim-index-front int32 :offset-assert 0)
|
|
(anim-index-back int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wlander-global-info (basic)
|
|
((prev-yellow-hit int8 :offset-assert 4)
|
|
(prev-blue-hit int8 :offset-assert 5)
|
|
(knocked UNKNOWN 2 :offset-assert 8)
|
|
(knocked-land UNKNOWN 2 :offset-assert 16)
|
|
(anim-knocked-front int32 :offset-assert 8)
|
|
(anim-knocked-back int32 :offset-assert 12)
|
|
(anim-knocked-front-land int32 :offset-assert 16)
|
|
(anim-knocked-back-land int32 :offset-assert 20)
|
|
(yellow-hit-anim UNKNOWN 2 :offset-assert 24)
|
|
(yellow-land-anim UNKNOWN 2 :offset-assert 40)
|
|
(blue-hit-anim UNKNOWN 1 :offset-assert 56)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *war-factory-vehicle-mask* object)
|
|
;; (define-extern *war-factory-effects-mask* object)
|
|
;; (define-extern *range-fac-dust-color* curve-color-fast)
|
|
;; (define-extern *range-fac-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-fac-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-fac-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-fac-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-fac-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-fac-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-hellcat-dust-landing-fac-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-sewj ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sewj-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sewer-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-color-sewer-gas* curve-color-fast)
|
|
;; (define-extern *range-alpha-sewer-gas* curve2d-fast)
|
|
;; (define-extern *range-scale-sewer-gas-x* curve2d-fast)
|
|
;; (define-extern *range-scale-sewer-gas-y* curve2d-fast)
|
|
;; (define-extern *r-curve-sewer-gas* curve2d-fast)
|
|
;; (define-extern *g-curve-sewer-gas* curve2d-fast)
|
|
;; (define-extern *b-curve-sewer-gas* curve2d-fast)
|
|
;; (define-extern *curve-alpha-sewer-gas* curve2d-fast)
|
|
;; (define-extern *curve-sewer-gas-x* curve2d-fast)
|
|
;; (define-extern *curve-sewer-gas-y* curve2d-fast)
|
|
;; (define-extern *part-sewer-steam-puff-curve-settings* object)
|
|
;; (define-extern *steam-particle-list* array)
|
|
;; (define-extern birth-func-texture-group-steam function)
|
|
;; (define-extern spt-func-birth-on-bubble-pop function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sewer-obs2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sew-laser-beam (process-drawable)
|
|
((sync sync-linear :inline :offset-assert 200)
|
|
(sound-id uint32 :offset-assert 216)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xdc
|
|
:flag-assert #x15006000dc
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-m-gate (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd0
|
|
:flag-assert #x17005000d0
|
|
(:state-methods
|
|
idle ;; 20
|
|
open ;; 21
|
|
raised ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-pipe (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd0
|
|
:flag-assert #x17005000d0
|
|
(:state-methods
|
|
idle ;; 20
|
|
lower ;; 21
|
|
down ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-grate-plat (process-drawable)
|
|
((test-pos vector :inline :offset-assert 208)
|
|
(closed-x float :offset-assert 224)
|
|
(opened-x float :offset-assert 228)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xe8
|
|
:flag-assert #x18007000e8
|
|
(:state-methods
|
|
closed ;; 20
|
|
open ;; 21
|
|
opened ;; 22
|
|
close ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern fire-sew-laser-beam! function)
|
|
;; (define-extern *sew-laser-beam-shadow-control* shadow-control)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sewer-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-jsplash-color* curve-color-fast)
|
|
;; (define-extern *range-jsplash-alpha* curve2d-fast)
|
|
;; (define-extern *range-jsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-jsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-jsplash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-jsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-jsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-sewer-water-splash-jak-curve-settings* object)
|
|
;; (define-extern *range-dsplash-color* curve-color-fast)
|
|
;; (define-extern *range-dsplash-alpha* curve2d-fast)
|
|
;; (define-extern *range-dsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-dsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-dsplash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-dsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-dsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-sewer-water-splash-daxter-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sew-laser-turret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; gun-turret-params is already defined!
|
|
|
|
#|
|
|
(deftype sew-laser-turret (enemy)
|
|
((params gun-turret-params :offset-assert 552)
|
|
(aim-pos vector :inline :offset-assert 560)
|
|
(smoke-part basic :offset-assert 576)
|
|
(casing-part basic :offset-assert 580)
|
|
(flash-state basic :offset-assert 584)
|
|
(can-shoot basic :offset-assert 588)
|
|
(last-active-time uint64 :offset-assert 592)
|
|
(target-distance float :offset-assert 600)
|
|
(target-on-ground basic :offset-assert 604)
|
|
(was-hit basic :offset-assert 608)
|
|
(awareness-radius float :offset-assert 612)
|
|
(ring-rate uint64 :offset-assert 616)
|
|
(max-num-rings int32 :offset-assert 624)
|
|
(last-spawn-index int32 :offset-assert 628)
|
|
(spin-sound-id uint32 :offset-assert 632)
|
|
(last-play-time uint64 :offset-assert 640)
|
|
(strip basic :offset-assert 648)
|
|
)
|
|
:method-count-assert 164
|
|
:size-assert #x28c
|
|
:flag-assert #xa40210028c
|
|
(:methods
|
|
(sew-laser-turret-method-159 () none) ;; 159
|
|
(sew-laser-turret-method-160 () none) ;; 160
|
|
(sew-laser-turret-method-161 () none) ;; 161
|
|
(sew-laser-turret-method-162 () none) ;; 162
|
|
(sew-laser-turret-method-163 () none) ;; 163
|
|
)
|
|
(:state-methods
|
|
spinning-up ;; 156
|
|
spinning-down ;; 157
|
|
alert ;; 155
|
|
turn-off ;; 158
|
|
hostile ;; 38
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *sew-laser-turret-enemy-info* enemy-info)
|
|
;; (define-extern do-spin function)
|
|
;; (define-extern compute-ring-period function)
|
|
;; (define-extern compute-ring-position function)
|
|
;; (define-extern compute-num-rings-to-draw function)
|
|
;; (define-extern compute-ring-size function)
|
|
;; (define-extern check-enemy function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sew-platforms ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sew-plat-updown (base-plat)
|
|
((sync sync-eased :inline :offset-assert 272)
|
|
(path-pos float :offset-assert 316)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x140
|
|
:flag-assert #x2600c00140
|
|
(:methods
|
|
(sew-plat-updown-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
idle ;; 35
|
|
active ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-slide-step (sew-plat-updown)
|
|
((last-played-start? basic :offset-assert 320)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x144
|
|
:flag-assert #x2600d00144
|
|
(:state-methods
|
|
active ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-moving-step-a (sew-plat-updown)
|
|
((last-played-start? basic :offset-assert 320)
|
|
(last-val float :offset-assert 324)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x148
|
|
:flag-assert #x2600d00148
|
|
(:state-methods
|
|
active ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-moving-step-b (process-drawable)
|
|
((sync sync-linear :inline :offset-assert 200)
|
|
(num-steps int8 :offset-assert 216)
|
|
(step-delay uint64 :offset-assert 224)
|
|
(start-step-pos vector :inline :offset-assert 240)
|
|
(end-step-pos vector :inline :offset-assert 256)
|
|
(last-sync-val float :offset-assert 272)
|
|
(sound-idle uint32 :offset-assert 276)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #x118
|
|
:flag-assert #x1b00a00118
|
|
(:methods
|
|
(sew-moving-step-b-method-22 () none) ;; 22
|
|
(sew-moving-step-b-method-23 () none) ;; 23
|
|
(sew-moving-step-b-method-24 () none) ;; 24
|
|
(sew-moving-step-b-method-25 () none) ;; 25
|
|
(sew-moving-step-b-method-26 () none) ;; 26
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-moving-step-b-step (base-plat)
|
|
((start-pos vector :inline :offset-assert 272)
|
|
(end-pos vector :inline :offset-assert 288)
|
|
(start-path-pos vector :inline :offset-assert 304)
|
|
(end-path-pos vector :inline :offset-assert 320)
|
|
(sync sync-linear :inline :offset-assert 336)
|
|
(path-pos float :offset-assert 352)
|
|
(last-t-val float :offset-assert 356)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x168
|
|
:flag-assert #x2500f00168
|
|
(:state-methods
|
|
die ;; 36
|
|
active ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-moving-step-b-step-param (structure)
|
|
((start-pos vector :inline :offset-assert 0)
|
|
(end-pos vector :inline :offset-assert 16)
|
|
(ent basic :offset-assert 32)
|
|
(period uint64 :offset-assert 40)
|
|
(offset float :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-rove-plat (sew-plat-updown)
|
|
((sound-id uint32 :offset-assert 320)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x144
|
|
:flag-assert #x2600d00144
|
|
(:state-methods
|
|
active ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sew-move-plat (base-plat)
|
|
((sound-id uint32 :offset-assert 272)
|
|
(positions UNKNOWN 2 :offset-assert 288)
|
|
(current-pos-index int8 :offset-assert 320)
|
|
(dest-pos-index int8 :offset-assert 321)
|
|
(speed float :offset-assert 324)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x148
|
|
:flag-assert #x2600d00148
|
|
(:methods
|
|
(sew-move-plat-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
waiting ;; 35
|
|
active ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sew-moving-step-b-step-init-by-other function)
|
|
;; (define-extern fmod function)
|
|
;; (define-extern spawn-moving-step-b-step function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; saberfish ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype saberfish-jump-info (structure)
|
|
((windup-anim uint32 :offset-assert 0)
|
|
(air-anim uint32 :offset-assert 4)
|
|
(land-anim uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish-init-by-other-params (enemy-init-by-other-params)
|
|
((spawn-parent uint64 :offset-assert 48)
|
|
(message basic :offset-assert 56)
|
|
(pos vector :inline :offset-assert 64)
|
|
(orient quaternion :inline :offset-assert 80)
|
|
(initial-state basic :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x64
|
|
:flag-assert #x900000064
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish-spawner-query-msg (structure)
|
|
((query-type uint64 :offset-assert 0)
|
|
(closest-nav-mesh-index int8 :offset-assert 8)
|
|
(pos vector :inline :offset-assert 16)
|
|
(behavior uint64 :offset-assert 32)
|
|
(nav-mesh-index int8 :offset-assert 8)
|
|
(mesh basic :offset-assert 16)
|
|
(in-water? basic :offset-assert 40)
|
|
(can-go-to-ground? basic :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype saberfish (nav-enemy)
|
|
((initial-y-angle float :offset-assert 620)
|
|
(last-attack-time uint64 :offset-assert 624)
|
|
(in-pursuit? basic :offset-assert 632)
|
|
(flee-to-readjust? basic :offset-assert 636)
|
|
(use-stored-flee-point? basic :offset-assert 640)
|
|
(scare-start-time uint64 :offset-assert 648)
|
|
(scare-time uint64 :offset-assert 656)
|
|
(jump-point-start vector :inline :offset-assert 672)
|
|
(jump-point-end vector :inline :offset-assert 688)
|
|
(align basic :offset-assert 148)
|
|
(jump saberfish-jump-info :inline :offset-assert 708)
|
|
(flee-point-temp vector :inline :offset-assert 720)
|
|
(last-land-check-time uint64 :offset-assert 736)
|
|
(last-target-check-time uint64 :offset-assert 744)
|
|
(is-submerged? basic :offset-assert 752)
|
|
(current-nav-mesh-index int8 :offset-assert 756)
|
|
(dest-nav-mesh-index int8 :offset-assert 757)
|
|
(desired-dest-nav-point vector :inline :offset-assert 768)
|
|
(desired-dest-mesh-index int8 :offset-assert 784)
|
|
(flee-point vector :inline :offset-assert 800)
|
|
(spawn-parent uint64 :offset-assert 816)
|
|
(pos-start vector :inline :offset-assert 832)
|
|
(quat-start quaternion :inline :offset-assert 848)
|
|
(move-to-ground? basic :offset-assert 864)
|
|
(swim-final-rotate-deg float :offset-assert 868)
|
|
(swim-travel-anim int8 :offset-assert 872)
|
|
(swim-speed float :offset-assert 876)
|
|
(swim-rotate-last-dot float :offset-assert 880)
|
|
(swim-anim-last-dot float :offset-assert 884)
|
|
(last-swim-flip-time uint64 :offset-assert 888)
|
|
(saberfish-y-rotate float :offset-assert 896)
|
|
(doing-180-spin? basic :offset-assert 900)
|
|
(adjusted-y-yet? basic :offset-assert 904)
|
|
(attack-dir vector :inline :offset-assert 912)
|
|
(rotate-anim-quat quaternion :inline :offset-assert 928)
|
|
(post-spinflip-expected-heading vector :inline :offset-assert 944)
|
|
(nav-velocity vector :inline :offset-assert 960)
|
|
(nav-dir vector :inline :offset-assert 976)
|
|
(initial-state basic :offset-assert 992)
|
|
(knocked-under-water? basic :offset-assert 996)
|
|
(ground-state uint8 :offset-assert 1000)
|
|
(jump-start-ground-state uint8 :offset-assert 1001)
|
|
(ground-only? basic :offset-assert 1004)
|
|
)
|
|
:method-count-assert 245
|
|
:size-assert #x3f0
|
|
:flag-assert #xf5037003f0
|
|
(:methods
|
|
(saberfish-method-195 () none) ;; 195
|
|
(saberfish-method-199 () none) ;; 199
|
|
(saberfish-method-201 () none) ;; 201
|
|
(saberfish-method-202 () none) ;; 202
|
|
(saberfish-method-210 () none) ;; 210
|
|
(saberfish-method-214 () none) ;; 214
|
|
(saberfish-method-215 () none) ;; 215
|
|
(saberfish-method-216 () none) ;; 216
|
|
(saberfish-method-217 () none) ;; 217
|
|
(saberfish-method-218 () none) ;; 218
|
|
(saberfish-method-219 () none) ;; 219
|
|
(saberfish-method-220 () none) ;; 220
|
|
(saberfish-method-221 () none) ;; 221
|
|
(saberfish-method-222 () none) ;; 222
|
|
(saberfish-method-223 () none) ;; 223
|
|
(saberfish-method-224 () none) ;; 224
|
|
(saberfish-method-225 () none) ;; 225
|
|
(saberfish-method-226 () none) ;; 226
|
|
(saberfish-method-227 () none) ;; 227
|
|
(saberfish-method-228 () none) ;; 228
|
|
(saberfish-method-229 () none) ;; 229
|
|
(saberfish-method-230 () none) ;; 230
|
|
(saberfish-method-231 () none) ;; 231
|
|
(saberfish-method-232 () none) ;; 232
|
|
(saberfish-method-233 () none) ;; 233
|
|
(saberfish-method-234 () none) ;; 234
|
|
(saberfish-method-235 () none) ;; 235
|
|
(saberfish-method-236 () none) ;; 236
|
|
(saberfish-method-237 () none) ;; 237
|
|
(saberfish-method-238 () none) ;; 238
|
|
(saberfish-method-239 () none) ;; 239
|
|
(saberfish-method-240 () none) ;; 240
|
|
(saberfish-method-241 () none) ;; 241
|
|
(saberfish-method-242 () none) ;; 242
|
|
(saberfish-method-243 () none) ;; 243
|
|
(saberfish-method-244 () none) ;; 244
|
|
)
|
|
(:state-methods
|
|
base-saberfish-state ;; 203
|
|
attack ;; 190
|
|
hostile ;; 38
|
|
hit ;; 30
|
|
hostile-orient ;; 191
|
|
stare-idle ;; 194
|
|
stare ;; 37
|
|
water-land ;; 200
|
|
swim-180-spin ;; 207
|
|
swimming-base ;; 208
|
|
swimming-hostile ;; 192
|
|
active ;; 34
|
|
spin-attack ;; 193
|
|
water-impact ;; 205
|
|
diving-into-water ;; 204
|
|
transition-terrain-jump ;; 198
|
|
transition-terrain-orient-towards-initial-jump ;; 197
|
|
transition-terrain-move-towards-initial-jump ;; 196
|
|
flee ;; 36
|
|
knocked ;; 31
|
|
knocked-recover-water ;; 212
|
|
knocked-recover ;; 32
|
|
idle ;; 33
|
|
notice ;; 35
|
|
command-mode ;; 206
|
|
saberfish-swimming ;; 213
|
|
saberfish-crawl-out-of-tube ;; 209
|
|
saberfish-sitting-on-land ;; 211
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern find-behavior<-in-water? function)
|
|
;; (define-extern in-water<-find-behavior function)
|
|
;; (define-extern *saberfish-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern get-spawn-parent function)
|
|
;; (define-extern saberfish-water-post function)
|
|
;; (define-extern saberfish-chase-post function)
|
|
;; (define-extern saberfish-orient-code-setup function)
|
|
;; (define-extern saberfish-orient-code-single-pass function)
|
|
;; (define-extern saberfish-orient-code function)
|
|
;; (define-extern saberfish-swim-code function)
|
|
;; (define-extern saberfish-swim-travel-trans function)
|
|
;; (define-extern swimming-base-exit function)
|
|
;; (define-extern transition-terrain-jump-from-water state)
|
|
;; (define-extern jump-from-land-dive-anim function)
|
|
;; (define-extern transition-terrain-jump-from-land state)
|
|
;; (define-extern transition-pursue-behavior function)
|
|
;; (define-extern turbo-swim function)
|
|
;; (define-extern saberfish-command-event-handler function)
|
|
;; (define-extern saberfish-init-by-other function)
|
|
;; (define-extern find-ground-for-obj function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flyingsaw ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flyingsaw-node (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(spark vector :inline :offset-assert 16)
|
|
(make-spark basic :offset-assert 32)
|
|
(pos-x float :offset-assert 0)
|
|
(pos-y float :offset-assert 4)
|
|
(pos-z float :offset-assert 8)
|
|
(spark-x float :offset-assert 16)
|
|
(spark-y float :offset-assert 20)
|
|
(spark-z float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flyingsaw-graph (structure)
|
|
((node-count uint16 :offset-assert 0)
|
|
(node uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flyingsaw (process-drawable)
|
|
((no-collision-timer uint64 :offset-assert 200)
|
|
(graph flyingsaw-graph :offset-assert 208)
|
|
(current-node uint16 :offset-assert 212)
|
|
(hip-angle float :offset-assert 216)
|
|
(blade-angle float :offset-assert 220)
|
|
(spin-1 basic :offset-assert 224)
|
|
(spin-2 basic :offset-assert 228)
|
|
(spin-3 basic :offset-assert 232)
|
|
(spin-4 basic :offset-assert 236)
|
|
(base-quat quaternion :inline :offset-assert 240)
|
|
(wobble-target delayed-rand-vector :inline :offset-assert 256)
|
|
(wobble oscillating-vector :inline :offset-assert 304)
|
|
(fly-sound uint32 :offset-assert 364)
|
|
(fly-sound-playing basic :offset-assert 368)
|
|
(spark-timer uint64 :offset-assert 376)
|
|
(spark-mat matrix :inline :offset-assert 384)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x1c0
|
|
:flag-assert #x15014001c0
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *flyingsaw_2-graph* object)
|
|
;; (define-extern *flyingsaw_3-graph* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; sewer-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *sewc-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewd-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewe-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewg-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewh-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewi-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewj-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewl-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewm-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *sewn-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; neo-juicer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype neo-juicer-shot (projectile)
|
|
((lightning UNKNOWN 5 :offset-assert 512)
|
|
(victim uint64 :offset-assert 536)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
(:state-methods
|
|
dissipate ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-juicer-anim-info (structure)
|
|
((anim-index int32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-juicer-global-info (basic)
|
|
((prev-yellow-hit int8 :offset-assert 4)
|
|
(prev-blue-hit int8 :offset-assert 5)
|
|
(idle-anim UNKNOWN 3 :offset-assert 8)
|
|
(patrol-anim UNKNOWN 2 :offset-assert 20)
|
|
(notice-anim UNKNOWN 2 :offset-assert 28)
|
|
(charge-anim UNKNOWN 2 :offset-assert 36)
|
|
(knocked-anim UNKNOWN 2 :offset-assert 44)
|
|
(celebrate-anim UNKNOWN 2 :offset-assert 52)
|
|
(yellow-hit-anim UNKNOWN 4 :offset-assert 60)
|
|
(blue-hit-anim UNKNOWN 6 :offset-assert 76)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x64
|
|
:flag-assert #x900000064
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-juicer (nav-enemy)
|
|
((los los-control :inline :offset-assert 624)
|
|
(intro-path basic :offset-assert 788)
|
|
(joint basic :offset-assert 792)
|
|
(joint-enable basic :offset-assert 796)
|
|
(joint-blend float :offset-assert 800)
|
|
(last-fire-time uint64 :offset-assert 808)
|
|
(heading basic :offset-assert 816)
|
|
(move-angle float :offset-assert 820)
|
|
(torso-track-player basic :offset-assert 824)
|
|
(circle-backward? basic :offset-assert 832)
|
|
(using-turn-anim basic :offset-assert 836)
|
|
(hit-focus basic :offset-assert 840)
|
|
(ambush-path-pt int8 :offset-assert 844)
|
|
(charge-index int8 :offset-assert 845)
|
|
(hostile-dest vector :inline :offset-assert 848)
|
|
(current-projectile uint64 :offset-assert 864)
|
|
)
|
|
:method-count-assert 197
|
|
:size-assert #x368
|
|
:flag-assert #xc502f00368
|
|
(:methods
|
|
(neo-juicer-method-192 () none) ;; 192
|
|
(neo-juicer-method-193 () none) ;; 193
|
|
(neo-juicer-method-194 () none) ;; 194
|
|
(neo-juicer-method-195 () none) ;; 195
|
|
(neo-juicer-method-196 () none) ;; 196
|
|
)
|
|
(:state-methods
|
|
active ;; 34
|
|
attack ;; 191
|
|
victory ;; 39
|
|
ambush ;; 47
|
|
hostile ;; 38
|
|
ambush-cont ;; 190
|
|
notice ;; 35
|
|
circling ;; 157
|
|
hit ;; 30
|
|
stare ;; 37
|
|
taunt ;; 155
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern neo-juicer-proj-move function)
|
|
;; (define-extern *neo-juicer-global-info* neo-juicer-global-info)
|
|
;; (define-extern *fact-info-neo-juicer-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *neo-juicer-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern neo-juicer-face-player-post function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; arena-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-wasp-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyindb-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype industrialb-board-vent (bouncer)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xd8
|
|
:flag-assert #x1b006000d8
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasdoors-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern do-stuff function)
|
|
;; (define-extern spt-birth-func-brightness-buggy-wasdoors-dirt function)
|
|
;; (define-extern spt-birth-func-part-wasdoors-buggy-skid-bits function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-turret-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype turret-shot (guard-shot)
|
|
((hit-pos vector :inline :offset-assert 544)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x230
|
|
:flag-assert #x2901b00230
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-turret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype target-turret-params (structure)
|
|
((fire-interval uint64 :offset-assert 0)
|
|
(max-health float :offset-assert 8)
|
|
(roty-accel float :offset-assert 12)
|
|
(roty-friction float :offset-assert 16)
|
|
(rotyv-max float :offset-assert 20)
|
|
(rotx-accel float :offset-assert 24)
|
|
(rotx-friction float :offset-assert 28)
|
|
(rotxv-max float :offset-assert 32)
|
|
(rotx-min float :offset-assert 36)
|
|
(rotx-max float :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype turret-info (basic)
|
|
((process (pointer process) :offset-assert 4) ;; guessed by decompiler
|
|
(handle uint64 :offset-assert 8) ;; handle
|
|
(turret (pointer base-turret) :offset-assert 16) ;; guessed by decompiler
|
|
(grabbed? symbol :offset-assert 20) ;; guessed by decompiler
|
|
(turret-type basic :offset-assert 24)
|
|
(exit? basic :offset-assert 28)
|
|
(quat quaternion :inline :offset-assert 32)
|
|
(trans vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype target-turret-info (structure)
|
|
((idle-anim int32 :offset-assert 0)
|
|
(camera-joint int32 :offset-assert 4)
|
|
(explode-sg basic :offset-assert 8)
|
|
(explode-params basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype target-turret (process-focusable)
|
|
((params target-turret-params :offset-assert 208)
|
|
(info target-turret-info :offset-assert 212)
|
|
(hud uint64 :offset-assert 216)
|
|
(shadow-backup basic :offset-assert 224)
|
|
(rider uint64 :offset-assert 232)
|
|
(smush-control smush-control :inline :offset-assert 240)
|
|
(fire-recoil smush-control :inline :offset-assert 272)
|
|
(sound-id UNKNOWN 3 :offset-assert 304)
|
|
(sound-playing UNKNOWN 3 :offset-assert 316)
|
|
(cam-string-vector vector :inline :offset-assert 336)
|
|
(pause-proc basic :offset-assert 352)
|
|
(shot-timeout uint64 :offset-assert 360)
|
|
(fire-time uint64 :offset-assert 368)
|
|
(fire-time-interval uint64 :offset-assert 376)
|
|
(focus-ignore-timer uint64 :offset-assert 384)
|
|
(enable-controls basic :offset-assert 392)
|
|
(roty deg :offset-assert 396)
|
|
(rotyv deg :offset-assert 400)
|
|
(rotyvv deg :offset-assert 404)
|
|
(roty-min deg :offset-assert 408)
|
|
(roty-max deg :offset-assert 412)
|
|
(rotx deg :offset-assert 416)
|
|
(rotxv deg :offset-assert 420)
|
|
(rotxvv deg :offset-assert 424)
|
|
(rotx-min deg :offset-assert 428)
|
|
(rotx-max deg :offset-assert 432)
|
|
(dest-roty deg :offset-assert 436)
|
|
(dest-rotx deg :offset-assert 440)
|
|
(target-quat quaternion :inline :offset-assert 448)
|
|
(init-trans vector :inline :offset-assert 464)
|
|
(init-quat quaternion :inline :offset-assert 480)
|
|
(health float :offset-assert 496)
|
|
(track-handle uint64 :offset-assert 504)
|
|
(heat float :offset-assert 512)
|
|
(heat-target float :offset-assert 516)
|
|
(arrow-angle float :offset-assert 520)
|
|
(arrow-alpha float :offset-assert 524)
|
|
(arrow-red float :offset-assert 528)
|
|
(red-filter-timer uint64 :offset-assert 536)
|
|
(ride-height float :offset-assert 544)
|
|
)
|
|
:method-count-assert 59
|
|
:size-assert #x224
|
|
:flag-assert #x3b01b00224
|
|
;; field pause-proc uses ~A with a signed load.
|
|
(:methods
|
|
(target-turret-method-34 () none) ;; 34
|
|
(target-turret-method-35 () none) ;; 35
|
|
(target-turret-method-36 () none) ;; 36
|
|
(target-turret-method-37 () none) ;; 37
|
|
(target-turret-method-38 () none) ;; 38
|
|
(target-turret-method-39 () none) ;; 39
|
|
(target-turret-method-40 () none) ;; 40
|
|
(target-turret-method-41 () none) ;; 41
|
|
(target-turret-method-42 () none) ;; 42
|
|
(target-turret-method-43 () none) ;; 43
|
|
(target-turret-method-44 () none) ;; 44
|
|
(target-turret-method-45 () none) ;; 45
|
|
(target-turret-method-46 () none) ;; 46
|
|
(target-turret-method-47 () none) ;; 47
|
|
(target-turret-method-48 () none) ;; 48
|
|
(target-turret-method-49 () none) ;; 49
|
|
(target-turret-method-50 () none) ;; 50
|
|
(target-turret-method-51 () none) ;; 51
|
|
(target-turret-method-52 () none) ;; 52
|
|
(target-turret-method-53 () none) ;; 53
|
|
(target-turret-method-54 () none) ;; 54
|
|
(target-turret-method-55 () none) ;; 55
|
|
(target-turret-method-56 () none) ;; 56
|
|
(target-turret-method-57 () none) ;; 57
|
|
(target-turret-method-58 () none) ;; 58
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
setup ;; 29
|
|
active ;; 30
|
|
shutdown ;; 31
|
|
dormant ;; 32
|
|
die ;; 33
|
|
)
|
|
(:states
|
|
target-turret-stance ;; associated process guessed by decompiler, old: (state handle target)
|
|
target-turret-get-off ;; associated process guessed by decompiler, old: (state target)
|
|
target-turret-stance-fire
|
|
target-turret-get-on ;; associated process guessed by decompiler, old: (state handle target)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *turret-exploder-params* joint-exploder-static-params) ;; joint-exploder-static-params
|
|
;; (define-extern *target-turret-params* object)
|
|
;; (define-extern target-turret-active-post function)
|
|
;; (define-extern turret-handler function) ;; (function process int symbol event-message-block object :behavior base-turret)
|
|
;; (define-extern target-turret-blend-mat function)
|
|
;; (define-extern cam-turret state) ;; (state camera-slave)
|
|
;; (define-extern target-turret-get-on-play function)
|
|
;; (define-extern target-for-turret-get-on-play function)
|
|
;; (define-extern target-turret-get-off-play function)
|
|
;; (define-extern target-for-turret-get-off-play function)
|
|
;; (define-extern target-turret-exit-turret? function)
|
|
;; (define-extern target-turret-stance-play function)
|
|
;; (define-extern target-for-turret-stance-play function)
|
|
;; (define-extern target-turret-stance-fire-play function)
|
|
;; (define-extern target-for-turret-stance-fire-play function)
|
|
;; (define-extern target-turret-stance-end function)
|
|
;; (define-extern target-for-turret-stance-end function)
|
|
;; (define-extern target-turret-post function) ;; (function none :behavior target)
|
|
;; (define-extern target-turret-stance-handler function)
|
|
;; (define-extern *turret-get-on-mods* object) ;; surface
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; skeet-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-skeet-dust-color* curve-color-fast)
|
|
;; (define-extern *range-skeet-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-skeet-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-skeet-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-skeet-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-skeet-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-skeet-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-skeet-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-skeet-color* curve-color-fast)
|
|
;; (define-extern *range-skeet-alpha* curve2d-fast)
|
|
;; (define-extern *range-skeet-scale-x* curve2d-fast)
|
|
;; (define-extern *range-skeet-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-skeet-alpha* curve2d-fast)
|
|
;; (define-extern *curve-skeet-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-skeet-scale-y* curve2d-fast)
|
|
;; (define-extern *part-skeet-explosion-texture-curve-settings* object)
|
|
;; (define-extern *range-skeet-splash-color* curve-color-fast)
|
|
;; (define-extern *range-skeet-splash-alpha* curve2d-fast)
|
|
;; (define-extern *range-skeet-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-skeet-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-skeet-splash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-skeet-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-skeet-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-skeet-splash-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dm-flyer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dm-flyer-shot (projectile)
|
|
((tail-pos vector :inline :offset-assert 512)
|
|
(hit-pos vector :inline :offset-assert 528)
|
|
(turn-quat quaternion :inline :offset-assert 544)
|
|
(minimap connection-minimap :offset-assert 560)
|
|
(hit-actor? basic :offset-assert 564)
|
|
(last-hit-time uint64 :offset-assert 568)
|
|
(muzzle-flash-part basic :offset-assert 576)
|
|
(particle-trail basic :offset-assert 580)
|
|
(swirl float :offset-assert 584)
|
|
(swirlvel float :offset-assert 588)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x250
|
|
:flag-assert #x2901d00250
|
|
(:state-methods
|
|
impact ;; 22
|
|
dissipate ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *dm-flyer-curve-linear-up-red* object)
|
|
;; (define-extern *dm-flyer-trail-color-curve-missile* curve-color-fast)
|
|
;; (define-extern *dm-flyer-curve-missile-linear-trail* curve2d-fast)
|
|
;; (define-extern *dm-flyer-missile-trail* object)
|
|
;; (define-extern dm-flyer-shot-move function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mine-train ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype min-bomb-train (process-focusable)
|
|
((path-pos float :offset-assert 208)
|
|
(path-length float :offset-assert 212)
|
|
(speed float :offset-assert 216)
|
|
(fall-travel-time float :offset-assert 220)
|
|
(actor-group uint32 :offset-assert 224)
|
|
(actor-group-count int32 :offset-assert 228)
|
|
(wheel-angle float :offset-assert 232)
|
|
(sound-loop-id uint32 :offset-assert 236)
|
|
(attack-id uint32 :offset-assert 240)
|
|
(spark-part basic :offset-assert 244)
|
|
(smoke-part basic :offset-assert 248)
|
|
(light-part basic :offset-assert 252)
|
|
(doors-exploded? basic :offset-assert 256)
|
|
(taskman uint64 :offset-assert 264)
|
|
(current-rail uint8 :offset-assert 272)
|
|
(suck-level float :offset-assert 276)
|
|
(minimap basic :offset-assert 280)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x11c
|
|
:flag-assert #x2900a0011c
|
|
(:methods
|
|
(min-bomb-train-method-35 () none) ;; 35
|
|
(min-bomb-train-method-36 () none) ;; 36
|
|
(min-bomb-train-method-37 () none) ;; 37
|
|
(min-bomb-train-method-38 () none) ;; 38
|
|
(min-bomb-train-method-39 () none) ;; 39
|
|
(min-bomb-train-method-40 () none) ;; 40
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
wait ;; 29
|
|
active ;; 30
|
|
die ;; 33
|
|
fall ;; 32
|
|
explode ;; 31
|
|
explode-doors ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *min-bomb-train-times* array)
|
|
;; (define-extern *min-bomb-train-debris-params* debris-static-params)
|
|
;; (define-extern min-bomb-train-callback function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wascity-turret-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wascity-turret-shot (guard-shot)
|
|
((hit-pos vector :inline :offset-assert 544)
|
|
(prev-smoke-pos vector :inline :offset-assert 560)
|
|
(smoke-part basic :offset-assert 576)
|
|
(hit-water? basic :offset-assert 580)
|
|
(rotangle float :offset-assert 584)
|
|
(rotrad float :offset-assert 588)
|
|
(right vector :inline :offset-assert 592)
|
|
(up vector :inline :offset-assert 608)
|
|
(polarity basic :offset-assert 624)
|
|
)
|
|
:method-count-assert 42
|
|
:size-assert #x274
|
|
:flag-assert #x2a02000274
|
|
(:methods
|
|
(wascity-turret-shot-method-41 () none) ;; 41
|
|
)
|
|
(:state-methods
|
|
impact ;; 22
|
|
moving ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *range-skeet-shot-splash-color* curve-color-fast)
|
|
;; (define-extern *range-skeet-shot-splash-alpha* curve2d-fast)
|
|
;; (define-extern *range-skeet-shot-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-skeet-shot-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-skeet-shot-splash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-skeet-shot-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-skeet-shot-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-wascity-turret-shot-hit-splash-curve-settings* object)
|
|
;; (define-extern wascity-turret-shot-move function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wascity-turret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *wascity-turret-speech-list* object)
|
|
;; (define-extern *wascity-turret-params* object)
|
|
;; (define-extern *wascity-turret* object)
|
|
;; (define-extern *wascity-turret-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *wascity-display-offset* object)
|
|
;; (define-extern *debug-control-params* object)
|
|
;; (define-extern wct-show-flut function)
|
|
;; (define-extern *wascity-turret-got-out-time* object)
|
|
;; (define-extern joint-mod-recoil function)
|
|
;; (define-extern wascity-turret-get-fire-pos function)
|
|
;; (define-extern wascity-turret-get-reticle-fire-pos function)
|
|
;; (define-extern *wascity-reticle-normal-color* object)
|
|
;; (define-extern *wascity-reticle-locked-color* object)
|
|
;; (define-extern wascity-turret-get-reticle-color function)
|
|
;; (define-extern wascity-turret-gun-pos function)
|
|
;; (define-extern wascity-turret-gun-aim function)
|
|
;; (define-extern wascity-turret-add-radar function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; test-bike ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype test-bike (h-bike-c)
|
|
()
|
|
:method-count-assert 162
|
|
:size-assert #x510
|
|
:flag-assert #xa204900510
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype evan-test-bike (h-bike-a)
|
|
()
|
|
:method-count-assert 162
|
|
:size-assert #x490
|
|
:flag-assert #xa204100490
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *test-bike-constants* object) ;; rigid-body-vehicle-constants
|
|
;; (define-extern *evan-test-bike-constants* object) ;; rigid-body-vehicle-constants
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; maker-projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *curve-maker-linear-up-red* object)
|
|
;; (define-extern *trail-color-curve-maker-grenade* curve-color-fast)
|
|
;; (define-extern *curve-maker-grenade-linear-trail* curve2d-fast)
|
|
;; (define-extern *maker-grenade-trail* object)
|
|
;; (define-extern *range-maker-grenade-explo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-maker-grenade-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-maker-grenade-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-maker-grenade-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-maker-grenade-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-maker-grenade-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-maker-grenade-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-maker-grenade-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-maker-grenade-explo-color* curve-color-fast)
|
|
;; (define-extern *range-maker-grenade-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-maker-grenade-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-maker-grenade-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-maker-grenade-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-maker-grenade-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-maker-grenade-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-maker-grenade-explosion-texture-curve-settings* object)
|
|
;; (define-extern maker-projectile-bounce-move function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasdef-hud ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasgun-hud ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-graph-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-branch (structure)
|
|
((node nav-node 2 :offset-assert 0) ;; guessed by decompiler
|
|
(src-node nav-node :offset-assert 0) ;; guessed by decompiler
|
|
(dest-node nav-node :offset-assert 4) ;; guessed by decompiler
|
|
(temp-dest-node-id int32 :offset-assert 4)
|
|
(speed-limit uint8 :offset-assert 8)
|
|
(density uint8 :offset-assert 9)
|
|
(clock-type uint8 :offset-assert 10) ;; nav-branch-clock-type
|
|
(clock-mask uint8 :offset-assert 11) ;; nav-branch-clock-mask
|
|
(territory uint8 :offset-assert 10)
|
|
(exclusive-branch-id uint8 :offset-assert 11)
|
|
(max-user-count uint8 :offset-assert 12)
|
|
(user-count uint8 :offset-assert 13)
|
|
(width uint8 :offset-assert 14)
|
|
(flags uint8 :offset-assert 15) ;; nav-branch-flags
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x10
|
|
:flag-assert #x1500000010
|
|
(:methods
|
|
(nav-branch-method-9 () none) ;; 9 ;; (set-default-density-speed-and-width (_type_) none 9)
|
|
(nav-branch-method-10 () none) ;; 10 ;; (debug-print (_type_ object int) none 10)
|
|
(nav-branch-method-11 () none) ;; 11 ;; (get-density (_type_) float 11)
|
|
(nav-branch-method-12 () none) ;; 12 ;; (get-speed-limit (_type_) float 12)
|
|
(nav-branch-method-13 () none) ;; 13 ;; (get-width (_type_) float 13)
|
|
(nav-branch-method-14 () none) ;; 14 ;; (user-limit-reached? (_type_) symbol 14)
|
|
(nav-branch-method-15 () none) ;; 15 ;; (dest-node-id-at-max? (_type_) symbol 15)
|
|
(nav-branch-method-16 () none) ;; 16 ;; (set-density (_type_ float) none 16)
|
|
(nav-branch-method-17 () none) ;; 17 ;; (set-speed-limit (_type_ float) none 17)
|
|
(nav-branch-method-18 () none) ;; 18 ;; (set-width (_type_ float) none 18)
|
|
(nav-branch-method-19 () none) ;; 19 ;; (set-src-node (_type_ nav-node) none 19)
|
|
(nav-branch-method-20 () none) ;; 20 ;; (set-dst-node (_type_ nav-node) none 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-node (structure)
|
|
((data uint32 32 :offset-assert 0) ;; guessed by decompiler
|
|
(position vector :inline :offset-assert 0)
|
|
(pos-x float :offset-assert 0)
|
|
(pos-y float :offset-assert 4)
|
|
(pos-z float :offset-assert 8)
|
|
(angle uint16 :offset-assert 12)
|
|
(id uint16 :offset-assert 14)
|
|
(radius uint8 :offset-assert 16)
|
|
(branch-count int8 :offset-assert 17)
|
|
(flags nav-node-flag :offset-assert 18) ;; nav-node-flag-byte
|
|
(pad0 int8 1 :offset-assert 19) ;; guessed by decompiler
|
|
(branch-array (inline-array nav-branch) :offset-assert 20) ;; guessed by decompiler
|
|
(nav-mesh-id uint32 :offset-assert 24)
|
|
(level symbol :offset-assert 28) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x20
|
|
:flag-assert #x1600000020
|
|
;; field nav-node-flag is likely a value type.
|
|
(:methods
|
|
(nav-node-method-9 () none) ;; 9 ;; (debug-draw (_type_) none 9)
|
|
(nav-node-method-10 () none) ;; 10 ;; (debug-print (_type_ symbol string) none 10)
|
|
(nav-node-method-11 () none) ;; 11 ;; (remove-branch-by-idx (_type_ int) none 11)
|
|
(nav-node-method-12 () none) ;; 12 ;; (init-from-pt-and-heading (_type_ vector vector) none 12)
|
|
(nav-node-method-13 () none) ;; 13 ;; (set-pos-xyz (_type_ vector) none 13)
|
|
(nav-node-method-14 () none) ;; 14 ;; (set-angle-from-heading (_type_ vector) none 14)
|
|
(nav-node-method-15 () none) ;; 15 ;; (set-id-and-link-branches-back (_type_ uint) none 15)
|
|
(nav-node-method-16 () none) ;; 16 ;; (set-radius (_type_ float) none 16)
|
|
(nav-node-method-17 () none) ;; 17 ;; (set-angle (_type_ float) none 17)
|
|
(nav-node-method-18 () none) ;; 18 ;; (get-position (_type_ vector) vector 18)
|
|
(nav-node-method-19 () none) ;; 19 ;; (calc-sine-and-cosine! (_type_ vector) vector 19)
|
|
(nav-node-method-20 () none) ;; 20 ;; (get-angle (_type_) float 20)
|
|
(nav-node-method-21 () none) ;; 21 ;; (get-radius (_type_) float 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-graph-link (structure)
|
|
((id uint32 :offset-assert 0)
|
|
(dest-graph-id uint32 :offset-assert 4)
|
|
(src-branch-id uint16 :offset-assert 8)
|
|
(dest-node-id uint16 :offset-assert 10)
|
|
(dest-graph basic :offset-assert 12)
|
|
(dummy-node nav-node :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nav-graph (basic)
|
|
((node-count int16 :offset-assert 4)
|
|
(branch-count int16 :offset-assert 6)
|
|
(node-array (inline-array nav-node) :offset-assert 8) ;; guessed by decompiler
|
|
(branch-array (inline-array nav-branch) :offset-assert 12) ;; guessed by decompiler
|
|
(link-count int16 :offset-assert 16)
|
|
(pad2 uint16 :offset-assert 18)
|
|
(link-array (inline-array nav-graph-link) :offset-assert 20) ;; guessed by decompiler
|
|
(first-node int16 :offset-assert 24)
|
|
(pad0 uint16 :offset-assert 26)
|
|
(patched symbol :offset-assert 28) ;; guessed by decompiler
|
|
(id uint32 :offset-assert 32)
|
|
(pad1 uint32 6 :offset-assert 36) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 45
|
|
:size-assert #x3c
|
|
:flag-assert #x2d0000003c
|
|
(:methods
|
|
;; (new (symbol type int int int uint) _type_ 0)
|
|
(nav-graph-method-9 () none) ;; 9 ;; (debug-draw-nodes (_type_) none 9)
|
|
(nav-graph-method-10 () none) ;; 10 ;; (nav-graph-method-10 (_type_ vector int) none 10)
|
|
(nav-graph-method-11 () none) ;; 11 ;; (nav-graph-method-11 (_type_) none 11)
|
|
(nav-graph-method-12 () none) ;; 12 ;; (nav-graph-method-12 (_type_) none 12)
|
|
(nav-graph-method-13 () none) ;; 13 ;; (nav-graph-method-13 (_type_ int int) none 13)
|
|
(nav-graph-method-14 () none) ;; 14 ;; (nav-graph-method-14 (_type_ int int) none 14)
|
|
(nav-graph-method-15 () none) ;; 15 ;; (debug-reset (_type_) none 15)
|
|
(nav-graph-method-16 () none) ;; 16 ;; (debug-add-node (_type_ int) nav-node 16)
|
|
(nav-graph-method-17 () none) ;; 17 ;; (debug-link-node-to-graph (_type_ nav-node) none 17)
|
|
(nav-graph-method-18 () none) ;; 18 ;; (debug-reset-branch-array (_type_ nav-node int) none 18)
|
|
(nav-graph-method-19 () none) ;; 19 ;; (nav-graph-method-19 (_type_ int int int int int int) none 19)
|
|
(nav-graph-method-20 () none) ;; 20 ;; (nav-graph-method-20 (_type_ int int) none 20)
|
|
(nav-graph-method-21 () none) ;; 21 ;; (move-selected-to-height-map-height (_type_) none 21)
|
|
(nav-graph-method-22 () none) ;; 22 ;; (select-nodes-in-range (_type_ int int) none 22)
|
|
(nav-graph-method-23 () none) ;; 23 ;; (deselect-nodes-in-range (_type_ int int) none 23)
|
|
(nav-graph-method-24 () none) ;; 24 ;; (toggle-select-nodes-in-range (_type_ int int) none 24)
|
|
(nav-graph-method-25 () none) ;; 25 ;; (select-nodes-in-level (_type_ symbol symbol) none 25)
|
|
(nav-graph-method-26 () none) ;; 26 ;; (select-nodes-by-nav-mesh-id (_type_ int symbol) none 26)
|
|
(nav-graph-method-27 () none) ;; 27 ;; (select-nodes-by-flags (_type_ nav-node-flag-byte nav-node-flag-byte symbol) none 27)
|
|
(nav-graph-method-28 () none) ;; 28 ;; (print-selected-nodes (_type_) none 28)
|
|
(nav-graph-method-29 () none) ;; 29 ;; (assign-selected-nodes-to-level (_type_ symbol) none 29)
|
|
(nav-graph-method-30 () none) ;; 30 ;; (assign-selected-nodes-to-nav-mesh (_type_ uint) none 30)
|
|
(nav-graph-method-31 () none) ;; 31 ;; (set-radius-of-selected-nodes (_type_ float) none 31)
|
|
(nav-graph-method-32 () none) ;; 32 ;; (set-speed-limit-of-selected (_type_ float) none 32)
|
|
(nav-graph-method-33 () none) ;; 33 ;; (set-density-of-selected (_type_ float) none 33)
|
|
(nav-graph-method-34 () none) ;; 34 ;; (set-width-of-selected (_type_ float) none 34)
|
|
(nav-graph-method-35 () none) ;; 35 ;; (or-flags-of-selected-nodes (_type_ nav-node-flag-byte) none 35)
|
|
(nav-graph-method-36 () none) ;; 36 ;; (and-flags-of-selected-nodes (_type_ nav-node-flag-byte) none 36)
|
|
(nav-graph-method-37 () none) ;; 37 ;; (offset-pos-of-selected (_type_ vector) none 37)
|
|
(nav-graph-method-38 () none) ;; 38 ;; (nav-graph-method-38 (_type_) none 38)
|
|
(nav-graph-method-39 () none) ;; 39 ;; (nav-graph-method-39 (_type_) none 39)
|
|
(nav-graph-method-40 () none) ;; 40 ;; (nav-graph-method-40 (_type_ int) int 40)
|
|
(nav-graph-method-41 () none) ;; 41 ;; (node-at-idx (_type_ int) nav-node 41)
|
|
(nav-graph-method-42 () none) ;; 42 ;; (patch-nodes (_type_) none 42)
|
|
(nav-graph-method-43 () none) ;; 43 ;; (copy-to-mysql-graph (_type_ mysql-nav-graph string) none 43)
|
|
(nav-graph-method-44 () none) ;; 44 ;; (from-editor (_type_ mysql-nav-graph symbol) none 44)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-lizard-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *catch-lizards-speech-list* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nst-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nsta-states (structure)
|
|
((poison-interp float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nstb-states (structure)
|
|
((poison-interp float :offset-assert 0)
|
|
(pulse UNKNOWN 5 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x54
|
|
:flag-assert #x900000054
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-nst-lights function)
|
|
;; (define-extern update-mood-nsta function)
|
|
;; (define-extern init-mood-nstb function)
|
|
;; (define-extern update-mood-nstb function)
|
|
;; (define-extern *nstb-light-mode* object)
|
|
;; (define-extern set-nstb-lights! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-borrow-manager-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype borrow-level-hold-info (structure)
|
|
((name basic :offset-assert 0)
|
|
(mode uint8 :offset-assert 4)
|
|
(expiring? basic :offset-assert 8)
|
|
(expire-start-time uint64 :offset-assert 16)
|
|
(expire-wait-time uint64 :offset-assert 24)
|
|
(num-remaining-objects uint16 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x22
|
|
:flag-assert #x900000022
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype borrow-level-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-borrow-manager (basic)
|
|
((borrow-holds basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 19
|
|
:size-assert #x8
|
|
:flag-assert #x1300000008
|
|
(:methods
|
|
(cty-borrow-manager-method-9 () none) ;; 9
|
|
(cty-borrow-manager-method-10 () none) ;; 10
|
|
(cty-borrow-manager-method-11 () none) ;; 11
|
|
(cty-borrow-manager-method-12 () none) ;; 12
|
|
(cty-borrow-manager-method-13 () none) ;; 13
|
|
(cty-borrow-manager-method-14 () none) ;; 14
|
|
(cty-borrow-manager-method-15 () none) ;; 15
|
|
(cty-borrow-manager-method-16 () none) ;; 16
|
|
(cty-borrow-manager-method-17 () none) ;; 17
|
|
(cty-borrow-manager-method-18 () none) ;; 18
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *city-borrow-manager* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-faction-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cty-faction-info (structure)
|
|
((data UNKNOWN 6 :offset-assert 0)
|
|
(ff-guard int8 :offset-assert 0)
|
|
(ff-ped int8 :offset-assert 1)
|
|
(kg-guard int8 :offset-assert 2)
|
|
(kg-ped int8 :offset-assert 3)
|
|
(mh-guard int8 :offset-assert 4)
|
|
(mh-ped int8 :offset-assert 5)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-faction-strength (structure)
|
|
((data UNKNOWN 3 :offset-assert 0)
|
|
(ff-strength int8 :offset-assert 0)
|
|
(kg-strength int8 :offset-assert 1)
|
|
(mh-strength int8 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3
|
|
:flag-assert #x900000003
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype territory-faction-mode (structure)
|
|
((data UNKNOWN 3 :offset-assert 0)
|
|
(ff-mode uint8 :offset-assert 0)
|
|
(kg-mode uint8 :offset-assert 1)
|
|
(mh-mode uint8 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3
|
|
:flag-assert #x900000003
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype territory-faction-flag (structure)
|
|
((data UNKNOWN 3 :offset-assert 0)
|
|
(ff-mode uint8 :offset-assert 0)
|
|
(kg-mode uint8 :offset-assert 1)
|
|
(mh-mode uint8 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3
|
|
:flag-assert #x900000003
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype faction-spawn-info (structure)
|
|
((faction-type uint8 :offset-assert 0)
|
|
(current-level uint8 :offset-assert 1)
|
|
(requested-level uint8 :offset-assert 2)
|
|
(flags uint8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-faction-manager (basic)
|
|
((faction-array UNKNOWN 30 :offset-assert 4)
|
|
(faction-mod-array UNKNOWN 30 :offset-assert 124)
|
|
(global-faction-strength-mod cty-faction-strength :inline :offset-assert 604)
|
|
(territory-faction-strength-mod UNKNOWN 4 :offset-assert 607)
|
|
(permission-cache UNKNOWN 30 :offset-assert 671)
|
|
(last-requested-level basic :offset-assert 704)
|
|
(territory-faction-modes UNKNOWN 30 :offset-assert 708)
|
|
(territory-flags UNKNOWN 30 :offset-assert 1188)
|
|
(last-active-territories uint32 :offset-assert 1220)
|
|
(update-flags uint8 :offset-assert 1224)
|
|
(target-exclusive-branch-index uint8 :offset-assert 1225)
|
|
(territory-faction-flags territory-faction-flag :inline :offset-assert 1226)
|
|
(faction-spawn UNKNOWN 7 :offset-assert 1229)
|
|
(last-change-music-time uint64 :offset-assert 1344)
|
|
(start-fight-music-time uint64 :offset-assert 1352)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x550
|
|
:flag-assert #x1a00000550
|
|
(:methods
|
|
(cty-faction-manager-method-9 () none) ;; 9
|
|
(cty-faction-manager-method-10 () none) ;; 10
|
|
(cty-faction-manager-method-11 () none) ;; 11
|
|
(cty-faction-manager-method-12 () none) ;; 12
|
|
(cty-faction-manager-method-13 () none) ;; 13
|
|
(cty-faction-manager-method-14 () none) ;; 14
|
|
(cty-faction-manager-method-15 () none) ;; 15
|
|
(cty-faction-manager-method-16 () none) ;; 16
|
|
(cty-faction-manager-method-17 () none) ;; 17
|
|
(cty-faction-manager-method-18 () none) ;; 18
|
|
(cty-faction-manager-method-19 () none) ;; 19
|
|
(cty-faction-manager-method-20 () none) ;; 20
|
|
(cty-faction-manager-method-21 () none) ;; 21
|
|
(cty-faction-manager-method-22 () none) ;; 22
|
|
(cty-faction-manager-method-23 () none) ;; 23
|
|
(cty-faction-manager-method-24 () none) ;; 24
|
|
(cty-faction-manager-method-25 () none) ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *cty-faction-manager* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcano-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vol-rising-step (process-drawable)
|
|
((sync sync-paused :inline :offset-assert 200)
|
|
(idle-anim int32 :offset-assert 224)
|
|
(amplitude float :offset-assert 228)
|
|
(init-y float :offset-assert 232)
|
|
(sound-id uint32 :offset-assert 236)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xf0
|
|
:flag-assert #x19007000f0
|
|
(:methods
|
|
(vol-rising-step-method-23 () none) ;; 23
|
|
(vol-rising-step-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
inactive ;; 20
|
|
pre-active ;; 21
|
|
active ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-rising-step-a (vol-rising-step)
|
|
()
|
|
:method-count-assert 25
|
|
:size-assert #xf0
|
|
:flag-assert #x19007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-rising-step-b (vol-rising-step)
|
|
()
|
|
:method-count-assert 25
|
|
:size-assert #xf0
|
|
:flag-assert #x19007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-rising-step-c (vol-rising-step)
|
|
()
|
|
:method-count-assert 25
|
|
:size-assert #xf0
|
|
:flag-assert #x19007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-rising-step-d (vol-rising-step)
|
|
()
|
|
:method-count-assert 25
|
|
:size-assert #xf0
|
|
:flag-assert #x19007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lava-shoot (process-drawable)
|
|
((sync sync-paused :inline :offset-assert 200)
|
|
(attack-id uint32 :offset-assert 224)
|
|
(sound-id uint32 :offset-assert 228)
|
|
(no-collision-timer uint64 :offset-assert 232)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xf0
|
|
:flag-assert #x15007000f0
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-balance-plat-chain-physics (chain-physics)
|
|
()
|
|
:method-count-assert 18
|
|
:size-assert #x570
|
|
:flag-assert #x1200000570
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-balance-plat (rigid-body-object)
|
|
((pivot-transform transformq :inline :offset-assert 288)
|
|
(init-pos vector :inline :offset-assert 336)
|
|
(force-pos vector :inline :offset-assert 352)
|
|
(rope basic :offset-assert 368)
|
|
(rope-initialized basic :offset-assert 372)
|
|
)
|
|
:method-count-assert 56
|
|
:size-assert #x178
|
|
:flag-assert #x3801000178
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-steam-explosion (process-drawable)
|
|
((sync sync-paused :inline :offset-assert 200)
|
|
(notify-actor basic :offset-assert 224)
|
|
(attack-id uint32 :offset-assert 228)
|
|
(lid-y float :offset-assert 232)
|
|
(extra-id int32 :offset-assert 236)
|
|
(y-speed float :offset-assert 240)
|
|
(sound-id uint32 :offset-assert 244)
|
|
(stopped-up-by uint64 :offset-assert 248)
|
|
(no-collision-timer uint64 :offset-assert 256)
|
|
(trigger-count int32 :offset-assert 264)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x10c
|
|
:flag-assert #x180090010c
|
|
(:methods
|
|
(vol-steam-explosion-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
stopped-up ;; 21
|
|
active ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spinning-hole (vol-steam-explosion)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #x10c
|
|
:flag-assert #x180090010c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-bouncer (bouncer)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xd8
|
|
:flag-assert #x1b006000d8
|
|
(:state-methods
|
|
idle ;; 20
|
|
fire ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-lava-ball (process-drawable)
|
|
((y-initial float :offset-assert 200)
|
|
(y-velocity float :offset-assert 204)
|
|
(y-acc float :offset-assert 208)
|
|
(attack-id uint32 :offset-assert 212)
|
|
(no-collision-timer uint64 :offset-assert 216)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xe0
|
|
:flag-assert #x16006000e0
|
|
(:state-methods
|
|
idle ;; 20
|
|
done ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-lava-ball-spout (process-drawable)
|
|
((sync sync-paused :inline :offset-assert 200)
|
|
(ball uint64 :offset-assert 224)
|
|
(ball-height float :offset-assert 232)
|
|
(sound-id uint32 :offset-assert 236)
|
|
(explode-time uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xf8
|
|
:flag-assert #x17008000f8
|
|
(:state-methods
|
|
idle ;; 20
|
|
going-active ;; 21
|
|
active ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-collapsing-rock (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:state-methods
|
|
inactive ;; 20
|
|
idle ;; 21
|
|
falling ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *vol-balance-plat-chain-setup* array)
|
|
;; (define-extern *vol-balance-plat-rigid-body-constants* object)
|
|
;; (define-extern vol-lava-ball-post function)
|
|
;; (define-extern vol-lava-ball-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-scorpion ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-scorpion (wcar-base)
|
|
((jmod-axles UNKNOWN 4 :offset-assert 2752)
|
|
(jmod-shock-tops UNKNOWN 4 :offset-assert 2880)
|
|
(jmod-shock-mids UNKNOWN 4 :offset-assert 3008)
|
|
(jmod-shock-bots UNKNOWN 4 :offset-assert 3264)
|
|
(jmod-gun-kick joint-mod-add-local :inline :offset-assert 3520)
|
|
(jmod-gun-tilt joint-mod-add-local :inline :offset-assert 3584)
|
|
(jmod-gun-turn joint-mod-rotate-local :inline :offset-assert 3648)
|
|
)
|
|
:method-count-assert 203
|
|
:size-assert #xe60
|
|
:flag-assert #xcb0de00e60
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; traffic-engine-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nav-segment (structure)
|
|
((vertex vector 2 :offset-assert 0) ;; guessed by decompiler
|
|
(length float :offset-assert 12)
|
|
(spawn-spacing float :offset-assert 28)
|
|
(branch nav-branch :offset-assert 32)
|
|
(nav-mesh-id uint32 :offset-assert 36)
|
|
(id uint16 :offset-assert 40)
|
|
(cell-id uint16 :offset-assert 42)
|
|
(from-cell-id uint16 :offset-assert 44)
|
|
(tracker-id int8 :offset-assert 46)
|
|
(pad0 int8 :offset-assert 47)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vis-cell (structure)
|
|
((sphere sphere :inline :offset-assert 0)
|
|
(segment-array (inline-array nav-segment) :offset-assert 16) ;; guessed by decompiler
|
|
(vis-id uint16 :offset-assert 20)
|
|
(id uint16 :offset-assert 22)
|
|
(incoming-segment-count int8 :offset-assert 24)
|
|
(segment-count int8 :offset-assert 25)
|
|
(flags vis-cell-flag :offset-assert 26)
|
|
(prev-flags vis-cell-flag :offset-assert 27)
|
|
(alloc-segment-count int8 :offset-assert 26)
|
|
(nav-territories uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x20
|
|
:flag-assert #xb00000020
|
|
;; field vis-cell-flag is likely a value type. field vis-cell-flag is likely a value type.
|
|
(:methods
|
|
(vis-cell-method-9 () none) ;; 9 ;; (reset-segment-counts (_type_) none 9)
|
|
(vis-cell-method-10 () none) ;; 10 ;; (debug-draw (_type_) none 10)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vis-grid-pos (structure)
|
|
((data int8 3 :offset-assert 0) ;; guessed by decompiler
|
|
(x int8 :offset-assert 0)
|
|
(y int8 :offset-assert 1)
|
|
(z int8 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3
|
|
:flag-assert #x900000003
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vis-grid-box (structure)
|
|
((min vis-grid-pos :inline :offset-assert 0)
|
|
(max vis-grid-pos :inline :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vis-ray (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(dir vector :inline :offset-assert 16)
|
|
(dest-pos vector :inline :offset-assert 32)
|
|
(plane plane :inline :offset-assert 48)
|
|
(grid-pos vis-grid-pos :inline :offset-assert 64)
|
|
(len float :offset-assert 68)
|
|
(cell vis-cell :offset-assert 72)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype grid-info (structure)
|
|
((axis-scale float 3 :offset-assert 0) ;; guessed by decompiler
|
|
(dimension-array int8 3 :offset-assert 12) ;; guessed by decompiler
|
|
(pad0 uint8 1 :offset-assert 15) ;; guessed by decompiler
|
|
(box bounding-box :inline :offset-assert 16)
|
|
(cell-size vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x40
|
|
:flag-assert #xe00000040
|
|
(:methods
|
|
(grid-info-method-9 () none) ;; 9 ;; (setup-grid-from-bounding-box (_type_ (pointer bounding-box) int int) none 9)
|
|
(grid-info-method-10 () none) ;; 10 ;; (lookup-cell-for-point (_type_ vis-grid-pos vector) none 10)
|
|
(grid-info-method-11 () none) ;; 11 ;; (lookup-box-for-sphere (_type_ vis-grid-box vector) none 11)
|
|
(grid-info-method-12 () none) ;; 12 ;; (debug-draw-grid (_type_ rgba) none 12)
|
|
(grid-info-method-13 () none) ;; 13 ;; (debug-draw-cell (_type_ vis-grid-pos rgba) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-level-info (structure)
|
|
((grid-info grid-info :inline :offset-assert 0)
|
|
(cell-array (inline-array vis-cell) :offset-assert 64) ;; guessed by decompiler
|
|
(segment-count int16 :offset-assert 68)
|
|
(cell-count uint16 :offset-assert 70)
|
|
(segment-array (inline-array nav-segment) :offset-assert 72) ;; guessed by decompiler
|
|
(nav-graph nav-graph :offset-assert 76) ;; guessed by decompiler
|
|
(camera-ceiling meters :offset-assert 80)
|
|
(pad-array int8 56 :offset-assert 84) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 19
|
|
:size-assert #x8c
|
|
:flag-assert #x130000008c
|
|
(:methods
|
|
(city-level-info-method-9 () none) ;; 9 ;; (city-level-info-method-9 (_type_) symbol 9)
|
|
(city-level-info-method-10 () none) ;; 10 ;; (init-vis-ray (_type_ vis-ray vector vector) none 10)
|
|
(city-level-info-method-11 () none) ;; 11 ;; (city-level-info-method-11 (_type_ vis-ray) none 11)
|
|
(city-level-info-method-12 () none) ;; 12 ;; (city-level-info-method-12 (_type_ vector nav-branch vector) vector 12)
|
|
(city-level-info-method-13 () none) ;; 13 ;; (lookup-cell-by-position (_type_ vector) vis-cell 13)
|
|
(city-level-info-method-14 () none) ;; 14 ;; (get-first-cell-in-box (_type_ vis-grid-box) vis-cell 14)
|
|
(city-level-info-method-15 () none) ;; 15 ;; (sphere-in-grid? (_type_ vector int) symbol 15)
|
|
(city-level-info-method-16 () none) ;; 16 ;; (callback-on-nav-segments-in-sphere (_type_ vector int traffic-find-segment-struct (function traffic-find-segment-struct nav-segment none)) none 16)
|
|
(city-level-info-method-17 () none) ;; 17 ;; (update-suppressions-from-traffic-engine (_type_ traffic-engine) none 17)
|
|
(city-level-info-method-18 () none) ;; 18 ;; (city-level-info-method-18 (_type_) none 18)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-level-data (structure)
|
|
((city-info city-level-info :offset-assert 0)
|
|
(active-cell-count uint8 :offset-assert 4)
|
|
(newly-active-cell-count uint8 :offset-assert 5)
|
|
(active-cell-list vis-cell 255 :offset-assert 8) ;; guessed by decompiler
|
|
(newly-active-cell-list vis-cell 255 :offset-assert 1028) ;; guessed by decompiler
|
|
(active-cell-box bounding-box :inline :offset-assert 2048)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x820
|
|
:flag-assert #xf00000820
|
|
(:methods
|
|
(traffic-level-data-method-9 () none) ;; 9 ;; (reset (_type_) none 9)
|
|
(traffic-level-data-method-10 () none) ;; 10 ;; (add-active-cell (_type_ vis-cell) none 10)
|
|
(traffic-level-data-method-11 () none) ;; 11 ;; (remove-active-cell (_type_ int) none 11)
|
|
(traffic-level-data-method-12 () none) ;; 12 ;; (add-newly-active-cell (_type_ vis-cell) none 12)
|
|
(traffic-level-data-method-13 () none) ;; 13 ;; (per-frame-cell-update (_type_) none 13)
|
|
(traffic-level-data-method-14 () none) ;; 14 ;; (debug-draw (_type_) none 14)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-suppression-box (structure)
|
|
((data uint8 32 :offset-assert 0) ;; guessed by decompiler
|
|
(bbox bounding-box :inline :offset-assert 0)
|
|
(flags uint8 :offset-assert 12) ;; traffic-suppression-box-flags
|
|
(duration uint32 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-object-type-info (structure)
|
|
((flags uint8 :offset-assert 0) ;; traffic-type-flags
|
|
(active-count int8 :offset-assert 1)
|
|
(inactive-count int8 :offset-assert 2)
|
|
(reserve-count uint16 :offset-assert 4)
|
|
(killed-count uint16 :offset-assert 6)
|
|
(want-count int8 :offset-assert 8)
|
|
(tracker-index uint8 :offset-assert 9)
|
|
(parking-spot-prob uint8 :offset-assert 10)
|
|
(guard-type uint8 :offset-assert 11)
|
|
(array (pointer handle) :offset-assert 12) ;; guessed by decompiler
|
|
(level symbol :offset-assert 16) ;; guessed by decompiler
|
|
(target-counts UNKNOWN 3 :offset-assert 20)
|
|
(target-count int8 :offset-assert 20)
|
|
(target-count-war int8 :offset-assert 21)
|
|
(target-count-mission int8 :offset-assert 22)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x17
|
|
:flag-assert #x900000017
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-suppressor (structure)
|
|
((flags uint8 :offset-assert 0) ;; traffic-suppression-flags
|
|
(bbox bounding-box :inline :offset-assert 16)
|
|
(array traffic-suppression-box 16 :offset-assert 48) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x230
|
|
:flag-assert #xe00000230
|
|
(:methods
|
|
(traffic-suppressor-method-9 () none) ;; 9 ;; (reset-boxes (_type_) none 9)
|
|
(traffic-suppressor-method-10 () none) ;; 10 ;; (add-new-supression-box (_type_ traffic-suppression-params) none 10)
|
|
(traffic-suppressor-method-11 () none) ;; 11 ;; (remove-box-by-id (_type_ int) none 11)
|
|
(traffic-suppressor-method-12 () none) ;; 12 ;; (update-box-from-params (_type_ traffic-suppression-params) none 12)
|
|
(traffic-suppressor-method-13 () none) ;; 13 ;; (debug-draw (_type_) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-tracker (structure)
|
|
((traffic traffic-engine :offset-assert 0) ;; guessed by decompiler
|
|
(object-hash spatial-hash :offset-assert 4) ;; guessed by decompiler
|
|
(rand float :offset-assert 8)
|
|
(id uint8 :offset-assert 12)
|
|
(active-object-count uint8 :offset-assert 13)
|
|
(inactive-object-count int8 :offset-assert 14)
|
|
(active-object-list handle 126 :offset-assert 16) ;; guessed by decompiler
|
|
(active-object-type-list traffic-type 126 :offset-assert 1024) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #x47e
|
|
:flag-assert #x1b0000047e
|
|
(:methods
|
|
(traffic-tracker-method-9 () none) ;; 9 ;; (traffic-tracker-method-9 (_type_) none 9)
|
|
(traffic-tracker-method-10 () none) ;; 10 ;; (traffic-tracker-method-10 (_type_) none 10)
|
|
(traffic-tracker-method-11 () none) ;; 11 ;; (traffic-tracker-method-11 (_type_) none 11)
|
|
(traffic-tracker-method-12 () none) ;; 12 ;; (add-active-process (_type_ traffic-type handle) none 12)
|
|
(traffic-tracker-method-13 () none) ;; 13 ;; (remove-active-process (_type_ int) handle 13)
|
|
(traffic-tracker-method-14 () none) ;; 14 ;; (add-reserved-process (_type_ traffic-type handle) none 14)
|
|
(traffic-tracker-method-15 () none) ;; 15 ;; (get-from-inactive-by-type (_type_ traffic-type) handle 15)
|
|
(traffic-tracker-method-16 () none) ;; 16 ;; (get-from-inactive-by-handle (_type_ traffic-type handle) handle 16)
|
|
(traffic-tracker-method-17 () none) ;; 17 ;; (deactivate-object (_type_ int symbol) none 17)
|
|
(traffic-tracker-method-18 () none) ;; 18 ;; (set-process-to-killed (_type_ process) none 18)
|
|
(traffic-tracker-method-19 () none) ;; 19 ;; (deactivate-all (_type_ symbol) none 19)
|
|
(traffic-tracker-method-20 () none) ;; 20 ;; (deactivate-all-of-type (_type_ traffic-type symbol) none 20)
|
|
(traffic-tracker-method-21 () none) ;; 21 ;; (activate-from-params (_type_ traffic-object-spawn-params) none 21)
|
|
(traffic-tracker-method-22 () none) ;; 22 ;; (activate-by-type (_type_ traffic-type nav-segment float) none 22)
|
|
(traffic-tracker-method-23 () none) ;; 23 ;; (activate-by-handle (_type_ traffic-object-spawn-params) none 23)
|
|
(traffic-tracker-method-24 () none) ;; 24 ;; (reset (_type_ uint traffic-engine) none 24)
|
|
(traffic-tracker-method-25 () none) ;; 25 ;; (for-all-active-processes (_type_ (function process-focusable traffic-object-type-info none)) none 25)
|
|
(traffic-tracker-method-26 () none) ;; 26 ;; (for-all-active-processes-of-type (_type_ traffic-type (function process-focusable traffic-object-type-info none)) none 26)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-engine (basic)
|
|
((object-hash spatial-hash :offset-assert 4) ;; guessed by decompiler
|
|
(manager uint64 :offset-assert 8) ;; handle
|
|
(inv-density-factor float :offset-assert 16)
|
|
(sync-clock uint8 :offset-assert 20)
|
|
(sync-mask-8 uint8 :offset-assert 21)
|
|
(sync-mask-16 uint16 :offset-assert 22)
|
|
(sync-mask-32 uint32 :offset-assert 24)
|
|
(sync-array uint8 4 :offset-assert 28) ;; guessed by decompiler
|
|
(flags uint8 :offset-assert 32)
|
|
(squad-control-array UNKNOWN 4 :offset-assert 36)
|
|
(level-data-array traffic-level-data 2 :offset-assert 64) ;; guessed by decompiler
|
|
(object-type-info-array traffic-object-type-info 29 :offset-assert 4224) ;; guessed by decompiler
|
|
(tracker-array traffic-tracker 2 :offset-assert 5152) ;; guessed by decompiler
|
|
(inactive-object-array handle 580 :offset-assert 7456) ;; guessed by decompiler
|
|
(suppressor traffic-suppressor :inline :offset-assert 12096)
|
|
(danger-sphere-count int8 :offset-assert 12656)
|
|
(danger-sphere-array traffic-danger-info 4 :offset-assert 12672) ;; guessed by decompiler
|
|
(allow-spawning? basic :offset-assert 12928)
|
|
)
|
|
:method-count-assert 58
|
|
:size-assert #x3284
|
|
:flag-assert #x3a00003284
|
|
(:methods
|
|
;; (new (symbol type) _type_ 0)
|
|
(traffic-engine-method-9 () none) ;; 9 ;; (update-traffic (_type_) none 9)
|
|
(traffic-engine-method-10 () none) ;; 10 ;; (reset-and-init-from-manager (_type_ process) none 10)
|
|
(traffic-engine-method-11 () none) ;; 11 ;; (stop-alarm-sound (_type_) none 11)
|
|
(traffic-engine-method-12 () none) ;; 12 ;; (debug-unused (_type_) none 12)
|
|
(traffic-engine-method-13 () none) ;; 13 ;; (add-object (_type_ traffic-type process) none 13)
|
|
(traffic-engine-method-14 () none) ;; 14 ;; (sphere-in-loaded-city-infos? (_type_ vector int) symbol 14)
|
|
(traffic-engine-method-15 () none) ;; 15 ;; (activate-one-citizen (_type_ nav-segment float) none 15)
|
|
(traffic-engine-method-16 () none) ;; 16 ;; (activate-one-vehicle (_type_ nav-segment float) none 16)
|
|
(traffic-engine-method-17 () none) ;; 17 ;; (can-dest-be-used? (_type_ nav-branch) symbol 17)
|
|
(traffic-engine-method-18 () none) ;; 18 ;; (child-killed (_type_ process) none 18)
|
|
(traffic-engine-method-19 () none) ;; 19 ;; (deactivate-all-from-level (_type_ symbol) none 19)
|
|
(traffic-engine-method-20 () none) ;; 20 ;; (find-best-segment (_type_ vector vector int) nav-segment 20)
|
|
(traffic-engine-method-21 () none) ;; 21 ;; (callback-on-nav-segments-in-sphere (_type_ vector int traffic-find-segment-struct (function traffic-find-segment-struct nav-segment none)) none 21)
|
|
(traffic-engine-method-22 () none) ;; 22 ;; (add-danger (_type_ traffic-danger-info) none 22)
|
|
(traffic-engine-method-23 () none) ;; 23 ;; (guard-count (_type_) int 23)
|
|
(traffic-engine-method-24 () none) ;; 24 ;; (set-target-level (_type_ float) none 24)
|
|
(traffic-engine-method-25 () none) ;; 25 ;; (set-guard-target-level (_type_ float) none 25)
|
|
(traffic-engine-method-26 () none) ;; 26 ;; (deactivate-all (_type_) none 26)
|
|
(traffic-engine-method-27 () none) ;; 27 ;; (deactivate-by-type (_type_ traffic-type) none 27)
|
|
(traffic-engine-method-28 () none) ;; 28 ;; (maybe-increase-guard-aim-count (_type_) symbol 28)
|
|
(traffic-engine-method-29 () none) ;; 29 ;; (restore-default-settings (_type_) none 29)
|
|
(traffic-engine-method-30 () none) ;; 30 ;; (increase-alert-level (_type_ int target) none 30)
|
|
(traffic-engine-method-31 () none) ;; 31 ;; (decrease-alert-level (_type_ int) none 31)
|
|
(traffic-engine-method-32 () none) ;; 32 ;; (set-alert-level (_type_ int) none 32)
|
|
(traffic-engine-method-33 () none) ;; 33 ;; (set-max-alert-level (_type_ int) none 33)
|
|
(traffic-engine-method-34 () none) ;; 34 ;; (set-alert-duration (_type_ time-frame) none 34)
|
|
(traffic-engine-method-35 () none) ;; 35 ;; (get-alert-level (_type_) int 35)
|
|
(traffic-engine-method-36 () none) ;; 36 ;; (get-target (_type_) target 36)
|
|
(traffic-engine-method-37 () none) ;; 37 ;; (set-object-target-level (_type_ int float) none 37)
|
|
(traffic-engine-method-38 () none) ;; 38 ;; (set-object-target-count (_type_ int int) none 38)
|
|
(traffic-engine-method-39 () none) ;; 39 ;; (set-object-reserve-count (_type_ int uint) none 39)
|
|
(traffic-engine-method-40 () none) ;; 40 ;; (get-object-reserve-count (_type_ int) int 40)
|
|
(traffic-engine-method-41 () none) ;; 41 ;; (get-object-remaining-count (_type_ int) int 41)
|
|
(traffic-engine-method-42 () none) ;; 42 ;; (activate-object (_type_ traffic-object-spawn-params) none 42)
|
|
(traffic-engine-method-43 () none) ;; 43 ;; (activate-by-handle (_type_ traffic-object-spawn-params) none 43)
|
|
(traffic-engine-method-44 () none) ;; 44 ;; (set-parking-spot-prob (_type_ int float) none 44)
|
|
(traffic-engine-method-45 () none) ;; 45 ;; (get-random-parking-spot-type (_type_) traffic-type 45)
|
|
(traffic-engine-method-46 () none) ;; 46 ;; (new-suppression-box (_type_ traffic-suppression-params) none 46)
|
|
(traffic-engine-method-47 () none) ;; 47 ;; (remove-suppression-box (_type_ traffic-suppression-params) none 47)
|
|
(traffic-engine-method-48 () none) ;; 48 ;; (update-suppression-box (_type_ traffic-suppression-params) none 48)
|
|
(traffic-engine-method-49 () none) ;; 49 ;; (traffic-engine-method-49 (_type_ vector int traffic-target-status) traffic-target-status 49)
|
|
(traffic-engine-method-50 () none) ;; 50 ;; (find-closest-to-with-collide-lists (_type_ process-drawable collide-spec) process-focusable 50)
|
|
(traffic-engine-method-51 () none) ;; 51 ;; (for-all-active-processes (_type_ (function process-focusable traffic-object-type-info none)) none 51)
|
|
(traffic-engine-method-52 () none) ;; 52 ;; (send-alert-events (_type_) none 52)
|
|
(traffic-engine-method-53 () none) ;; 53 ;; (end-pursuit-by-type (_type_ traffic-type) none 53)
|
|
(traffic-engine-method-54 () none) ;; 54 ;; (get-traffic-guard-type-settings (_type_ int) traffic-guard-type-settings 54)
|
|
(traffic-engine-method-55 () none) ;; 55 ;; (get-guard-type-for-traffic-obj (_type_ int) uint 55)
|
|
(traffic-engine-method-56 () none) ;; 56 ;; (get-traffic-guard-change-to-type (_type_ int) uint 56)
|
|
(traffic-engine-method-57 () none) ;; 57 ;; (set-guard-target-count-range (_type_ int int int) none 57)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mine-platforms ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mine-platform-base (base-plat)
|
|
()
|
|
:method-count-assert 38
|
|
:size-assert #x110
|
|
:flag-assert #x2600900110
|
|
(:methods
|
|
(mine-platform-base-method-36 () none) ;; 36
|
|
(mine-platform-base-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
plat-base-state ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-moving-plat-spooler (process-drawable)
|
|
((spool-sound uint32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:methods
|
|
(min-moving-plat-spooler-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-moving-plat (mine-platform-base)
|
|
((animation-speed float :offset-assert 272)
|
|
(sync sync-linear :inline :offset-assert 280)
|
|
(min-frame-num float :offset-assert 296)
|
|
(max-frame-num float :offset-assert 300)
|
|
(sound-drill-spool uint32 :offset-assert 304)
|
|
(sound-loop uint32 :offset-assert 308)
|
|
(sound-bit uint32 :offset-assert 312)
|
|
(sound-gear uint32 :offset-assert 316)
|
|
(last-frame float :offset-assert 320)
|
|
(spooler uint64 :offset-assert 328)
|
|
(sync-offset float :offset-assert 336)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x154
|
|
:flag-assert #x2800e00154
|
|
(:state-methods
|
|
idle ;; 38
|
|
active ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-rotating-plat (mine-platform-base)
|
|
((animation-speed float :offset-assert 272)
|
|
(sync sync-linear :inline :offset-assert 280)
|
|
(sound-loop-id uint32 :offset-assert 296)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x12c
|
|
:flag-assert #x2800b0012c
|
|
(:state-methods
|
|
idle ;; 38
|
|
active ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-falling-elevator (elevator)
|
|
((wheel-angle float :offset-assert 416)
|
|
(stop-sound basic :offset-assert 420)
|
|
)
|
|
:method-count-assert 55
|
|
:size-assert #x1ac
|
|
:flag-assert #x37013001ac
|
|
(:state-methods
|
|
running ;; 37
|
|
falling ;; 53
|
|
arrived ;; 38
|
|
resetting ;; 54
|
|
unstable ;; 52
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-falling-step (mine-platform-base)
|
|
((should-fall basic :offset-assert 268)
|
|
(actor-group uint32 :offset-assert 272)
|
|
(actor-group-count int32 :offset-assert 276)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x11c
|
|
:flag-assert #x2900a0011c
|
|
(:state-methods
|
|
idle ;; 38
|
|
lowering ;; 39
|
|
lowered ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-elev-track (elevator)
|
|
()
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-folding-plat (process-drawable)
|
|
((stop-sound basic :offset-assert 200)
|
|
(sound-id uint32 :offset-assert 204)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xd0
|
|
:flag-assert #x18005000d0
|
|
(:methods
|
|
(min-folding-plat-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
extend ;; 21
|
|
extended ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-ramp (process-drawable)
|
|
((angle float :offset-assert 200)
|
|
(play-anim? basic :offset-assert 204)
|
|
(play-ramp-sound? basic :offset-assert 208)
|
|
(stop-ramp-sound basic :offset-assert 212)
|
|
(ramp-sound uint32 :offset-assert 216)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xdc
|
|
:flag-assert #x17006000dc
|
|
(:state-methods
|
|
idle ;; 20
|
|
rotating ;; 21
|
|
rotated ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-bridge (process-drawable)
|
|
((stop-bridge-sound basic :offset-assert 200)
|
|
(bridge-sound uint32 :offset-assert 204)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xd0
|
|
:flag-assert #x18005000d0
|
|
(:methods
|
|
(min-bridge-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
extend ;; 21
|
|
extended ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-plat-updown (base-plat)
|
|
((sync sync-eased :inline :offset-assert 272)
|
|
(path-pos float :offset-assert 316)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x140
|
|
:flag-assert #x2600c00140
|
|
(:methods
|
|
(min-plat-updown-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
idle ;; 35
|
|
active ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-moving-step (min-plat-updown)
|
|
((holding? basic :offset-assert 320)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x144
|
|
:flag-assert #x2700d00144
|
|
(:state-methods
|
|
dormant ;; 38
|
|
active ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-elevator (elevator)
|
|
()
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
(:state-methods
|
|
running ;; 37
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern min-moving-plat-spooler-init-by-other function)
|
|
;; (define-extern *drill-loop-mid-curve* object)
|
|
;; (define-extern min-falling-elevator-callback function)
|
|
;; (define-extern min-ramp-callback function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nav-graph ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern make-nav-graph function) ;; (function mysql-nav-graph symbol none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; forest-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *foresta-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *forestb-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *lforplnt-pris-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; squad-control-city-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype squad-control-city (squad-control)
|
|
((sync-clock uint8 :offset-assert 4)
|
|
(sync-mask-8 uint8 :offset-assert 5)
|
|
(sync-mask-16 uint16 :offset-assert 6)
|
|
(sync-mask-32 uint32 :offset-assert 8)
|
|
(alert-state squad-alert-state :inline :offset-assert 16)
|
|
(primary-target-history UNKNOWN 16 :offset-assert 304)
|
|
(traffic basic :offset-assert 816)
|
|
(city-mode uint32 :offset-assert 820)
|
|
)
|
|
:method-count-assert 45
|
|
:size-assert #x338
|
|
:flag-assert #x2d00000338
|
|
(:methods
|
|
(squad-control-city-method-34 () none) ;; 34
|
|
(squad-control-city-method-35 () none) ;; 35
|
|
(squad-control-city-method-36 () none) ;; 36
|
|
(squad-control-city-method-37 () none) ;; 37
|
|
(squad-control-city-method-38 () none) ;; 38
|
|
(squad-control-city-method-39 () none) ;; 39
|
|
(squad-control-city-method-40 () none) ;; 40
|
|
(squad-control-city-method-41 () none) ;; 41
|
|
(squad-control-city-method-42 () none) ;; 42
|
|
(squad-control-city-method-43 () none) ;; 43
|
|
(squad-control-city-method-44 () none) ;; 44
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; traffic-height-map ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *traffic-height-map* object) ;; xz-height-map
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kg-squad-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype handle-array (inline-array-class-uint64)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-squad-member-settings (structure)
|
|
((object-type uint8 :offset-assert 0)
|
|
(max-target-count int8 :offset-assert 1)
|
|
(min-target-count int8 :offset-assert 2)
|
|
(target-count int8 :offset-assert 3)
|
|
(enemy-type uint8 :offset-assert 4)
|
|
(toggle-shield-percentage float :offset-assert 8)
|
|
(heat-shield-percentage float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-squad-settings (structure)
|
|
((roboguard-settings kg-squad-member-settings :inline :offset-assert 0)
|
|
(roboguard-giant-settings kg-squad-member-settings :inline :offset-assert 16)
|
|
(flying-turret-settings kg-squad-member-settings :inline :offset-assert 32)
|
|
(spydroid-settings kg-squad-member-settings :inline :offset-assert 48)
|
|
(kg-enemy-settings UNKNOWN 4 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-squad-control (squad-control-city)
|
|
((guard-to-traffic-mapping UNKNOWN 10 :offset-assert 824)
|
|
(guard-to-squad-setting-mapping UNKNOWN 10 :offset-assert 834)
|
|
(used-guard-types uint32 :offset-assert 844)
|
|
(active-squad-member-list basic :offset-assert 852)
|
|
(enemy-type-seek-to-list UNKNOWN 3 :offset-assert 856)
|
|
(enemy-type-seek-from-list UNKNOWN 3 :offset-assert 859)
|
|
(enemy-type-seek-to uint8 :offset-assert 856)
|
|
(enemy-type-seek-from uint8 :offset-assert 859)
|
|
(enemy-type-seek-to-war uint8 :offset-assert 857)
|
|
(enemy-type-seek-from-war uint8 :offset-assert 860)
|
|
(enemy-type-seek-to-mission uint8 :offset-assert 858)
|
|
(enemy-type-seek-from-mission uint8 :offset-assert 861)
|
|
(alert-level int8 :offset-assert 862)
|
|
(squad-settings UNKNOWN 3 :offset-assert 864)
|
|
(squad-normal-settings kg-squad-settings :inline :offset-assert 864)
|
|
(squad-war-settings kg-squad-settings :inline :offset-assert 928)
|
|
(squad-mission-settings kg-squad-settings :inline :offset-assert 992)
|
|
(current-target-attackers int8 :offset-assert 1056)
|
|
)
|
|
:method-count-assert 55
|
|
:size-assert #x421
|
|
:flag-assert #x3700000421
|
|
(:methods
|
|
(kg-squad-control-method-45 () none) ;; 45
|
|
(kg-squad-control-method-46 () none) ;; 46
|
|
(kg-squad-control-method-47 () none) ;; 47
|
|
(kg-squad-control-method-48 () none) ;; 48
|
|
(kg-squad-control-method-49 () none) ;; 49
|
|
(kg-squad-control-method-50 () none) ;; 50
|
|
(kg-squad-control-method-51 () none) ;; 51
|
|
(kg-squad-control-method-52 () none) ;; 52
|
|
(kg-squad-control-method-53 () none) ;; 53
|
|
(kg-squad-control-method-54 () none) ;; 54
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *kg-squad-control* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ff-squad-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype traffic-guard-type-info (structure)
|
|
((object-type uint8 :offset-assert 0) ;; traffic-type
|
|
(max-target-count int8 :offset-assert 1)
|
|
(min-target-count int8 :offset-assert 2)
|
|
(target-count int8 :offset-assert 3)
|
|
(count int8 :offset-assert 4)
|
|
(change-to-type uint8 :offset-assert 5)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x6
|
|
:flag-assert #x900000006
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-guard-type-array (structure)
|
|
((data UNKNOWN 3 :offset-assert 0)
|
|
(guard-info-normal traffic-guard-type-info :inline :offset-assert 0)
|
|
(guard-info-war traffic-guard-type-info :inline :offset-assert 16)
|
|
(guard-info-mission traffic-guard-type-info :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype squad-alert-state-settings (structure)
|
|
((guard-settings-array UNKNOWN 10 :offset-assert 0)
|
|
(ped-tazer squad-unit-settings :inline :offset-assert 0)
|
|
(ped-rifle squad-unit-settings :inline :offset-assert 32)
|
|
(ped-grenade squad-unit-settings :inline :offset-assert 64)
|
|
(ped-waster squad-unit-settings :inline :offset-assert 96)
|
|
(bike-turret squad-unit-settings :inline :offset-assert 128)
|
|
(hellcat-turret squad-unit-settings :inline :offset-assert 160)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x140
|
|
:flag-assert #x900000140
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype traffic-target-formation (structure)
|
|
((circle-range UNKNOWN 16 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ff-squad-control (squad-control-city)
|
|
((squad-settings UNKNOWN 3 :offset-assert 824)
|
|
(settings squad-alert-state-settings :inline :offset-assert 824)
|
|
(settings-war squad-alert-state-settings :inline :offset-assert 1144)
|
|
(settings-mission squad-alert-state-settings :inline :offset-assert 1464)
|
|
(guard-type-info-array UNKNOWN 10 :offset-assert 1784)
|
|
(guard-type-mask-from-object-type UNKNOWN 29 :offset-assert 2264)
|
|
(target-formation-array UNKNOWN 3 :offset-assert 2380)
|
|
)
|
|
:method-count-assert 57
|
|
:size-assert #xa0c
|
|
:flag-assert #x3900000a0c
|
|
(:methods
|
|
(ff-squad-control-method-45 () none) ;; 45
|
|
(ff-squad-control-method-46 () none) ;; 46
|
|
(ff-squad-control-method-47 () none) ;; 47
|
|
(ff-squad-control-method-48 () none) ;; 48
|
|
(ff-squad-control-method-49 () none) ;; 49
|
|
(ff-squad-control-method-50 () none) ;; 50
|
|
(ff-squad-control-method-51 () none) ;; 51
|
|
(ff-squad-control-method-52 () none) ;; 52
|
|
(ff-squad-control-method-53 () none) ;; 53
|
|
(ff-squad-control-method-54 () none) ;; 54
|
|
(ff-squad-control-method-55 () none) ;; 55
|
|
(ff-squad-control-method-56 () none) ;; 56
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ff-squad-control* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-squad-control-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mh-squad-member-settings (structure)
|
|
((object-type uint8 :offset-assert 0)
|
|
(max-target-count int8 :offset-assert 1)
|
|
(min-target-count int8 :offset-assert 2)
|
|
(target-count int8 :offset-assert 3)
|
|
(toggle-shield-percentage float :offset-assert 4)
|
|
(heat-shield-percentage float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-squad-settings (structure)
|
|
((mh-enemy-settings UNKNOWN 3 :offset-assert 0)
|
|
(grunt-settings mh-squad-member-settings :inline :offset-assert 0)
|
|
(flitter-settings mh-squad-member-settings :inline :offset-assert 16)
|
|
(predator-settings mh-squad-member-settings :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-squad-control (squad-control-city)
|
|
((active-squad-member-list basic :offset-assert 828)
|
|
(squad-settings UNKNOWN 3 :offset-assert 832)
|
|
(squad-normal-settings mh-squad-settings :inline :offset-assert 832)
|
|
(squad-war-settings mh-squad-settings :inline :offset-assert 880)
|
|
(squad-mission-settings mh-squad-settings :inline :offset-assert 928)
|
|
(alert-level int8 :offset-assert 976)
|
|
(map-traffic-object-type-to-squad UNKNOWN 29 :offset-assert 977)
|
|
(current-target-attackers int8 :offset-assert 1006)
|
|
)
|
|
:method-count-assert 49
|
|
:size-assert #x3ef
|
|
:flag-assert #x31000003ef
|
|
(:methods
|
|
(mh-squad-control-method-45 () none) ;; 45
|
|
(mh-squad-control-method-46 () none) ;; 46
|
|
(mh-squad-control-method-47 () none) ;; 47
|
|
(mh-squad-control-method-48 () none) ;; 48
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *mh-squad-control* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-faction ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype exclusive-nav-mesh-info (structure)
|
|
((aid uint32 :offset-assert 0)
|
|
(exclusive-mask uint8 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5
|
|
:flag-assert #x900000005
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *territory-list* array)
|
|
;; (define-extern *default-faction-info* array)
|
|
;; (define-extern *default-faction-mod* object)
|
|
;; (define-extern *default-faction-strength-mod* object)
|
|
;; (define-extern setup-city-task-faction function)
|
|
;; (define-extern *exclusive-nav-mesh-list* array)
|
|
;; (define-extern map-symbol-to-nav-territory-type function)
|
|
;; (define-extern cty-faction-evaluate-commands function)
|
|
;; (define-extern is-faction-level-loaded? function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gungame-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gun-course-info (structure)
|
|
((course uint64 :offset-assert 0)
|
|
(start-door int8 :offset-assert 8)
|
|
(end-door int8 :offset-assert 9)
|
|
(text uint32 :offset-assert 12)
|
|
(etype basic :offset-assert 16)
|
|
(task-bronze uint16 :offset-assert 20)
|
|
(task-silver uint16 :offset-assert 22)
|
|
(task-gold uint16 :offset-assert 24)
|
|
(game-score uint8 :offset-assert 26)
|
|
(pass-speech uint16 :offset-assert 28)
|
|
(training-goal float :offset-assert 32)
|
|
(allowed-guns uint64 :offset-assert 40)
|
|
(start-gun int32 :offset-assert 48)
|
|
(ammo-type int32 :offset-assert 52)
|
|
(training-task uint16 :offset-assert 56)
|
|
(play-text uint32 :offset-assert 60)
|
|
(play-button uint64 :offset-assert 64)
|
|
(give-eggs? basic :offset-assert 72)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gungame-task-manager (task-manager)
|
|
((actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(course-list basic :offset-assert 244)
|
|
(activated-course gun-course-info :offset-assert 248)
|
|
(activated-course-id uint64 :offset-assert 252)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x108
|
|
:flag-assert #x2400900108
|
|
(:methods
|
|
(gungame-task-manager-method-34 () none) ;; 34
|
|
(gungame-task-manager-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
active-door-opening ;; 32
|
|
waiting ;; 33
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gungame-manager (process)
|
|
((actor-group uint32 :offset-assert 124)
|
|
(actor-group-count int32 :offset-assert 128)
|
|
(score int32 :offset-assert 132)
|
|
(course basic :offset-assert 136)
|
|
(course-crates UNKNOWN 32 :offset-assert 140)
|
|
(course-type uint64 :offset-assert 396)
|
|
(hud-score uint64 :offset-assert 404)
|
|
(hud-goal uint64 :offset-assert 412)
|
|
(task-gold uint16 :offset-assert 420)
|
|
(task-silver uint16 :offset-assert 422)
|
|
(task-bronze uint16 :offset-assert 424)
|
|
(end-door uint8 :offset-assert 426)
|
|
(start-door uint8 :offset-assert 427)
|
|
(game-score uint8 :offset-assert 428)
|
|
(training-goal float :offset-assert 432)
|
|
(training? basic :offset-assert 436)
|
|
(state-time uint64 :offset-assert 444)
|
|
(start-time uint64 :offset-assert 452)
|
|
(parent-taskmgr uint64 :offset-assert 460)
|
|
(goal-amount int8 :offset-assert 468)
|
|
(egg-amount int8 :offset-assert 469)
|
|
(pass-speech uint16 :offset-assert 470)
|
|
(primary-target-history UNKNOWN 16 :offset-assert 476)
|
|
(score-gold int32 :offset-assert 988)
|
|
(score-silver int32 :offset-assert 992)
|
|
(score-bronze int32 :offset-assert 996)
|
|
(score-high int32 :offset-assert 1000)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x3f0
|
|
:flag-assert #x20037003f0
|
|
(:methods
|
|
(gungame-manager-method-18 () none) ;; 18
|
|
(gungame-manager-method-19 () none) ;; 19
|
|
(gungame-manager-method-20 () none) ;; 20
|
|
(gungame-manager-method-21 () none) ;; 21
|
|
(gungame-manager-method-22 () none) ;; 22
|
|
(gungame-manager-method-23 () none) ;; 23
|
|
(gungame-manager-method-24 () none) ;; 24
|
|
(gungame-manager-method-25 () none) ;; 25
|
|
(gungame-manager-method-26 () none) ;; 26
|
|
(gungame-manager-method-27 () none) ;; 27
|
|
(gungame-manager-method-28 () none) ;; 28
|
|
(gungame-manager-method-29 () none) ;; 29
|
|
(gungame-manager-method-30 () none) ;; 30
|
|
(gungame-manager-method-31 () none) ;; 31
|
|
)
|
|
(:state-methods
|
|
course ;; 15
|
|
end-course-open-door ;; 17
|
|
end-course ;; 16
|
|
wait-start ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype training-path (process-drawable)
|
|
((num uint32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gungame-mgr-1 (gungame-manager)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #x3f0
|
|
:flag-assert #x21037003f0
|
|
(:state-methods
|
|
wait-load ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gungame-mgr-2 (gungame-manager)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #x3f0
|
|
:flag-assert #x21037003f0
|
|
(:state-methods
|
|
wait-load ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gungame-mgr-rnc (gungame-manager)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #x3f0
|
|
:flag-assert #x21037003f0
|
|
(:state-methods
|
|
wait-load ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gungame-mgr-3 (gungame-mgr-rnc)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #x3f0
|
|
:flag-assert #x21037003f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gungame-mgr-4 (gungame-mgr-rnc)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #x3f0
|
|
:flag-assert #x21037003f0
|
|
(:state-methods
|
|
wait-load ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype training-manager (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
;; (define-extern gungame-manager-init-by-other function)
|
|
;; (define-extern exit-course state)
|
|
;; (define-extern *jak3-training-path-info* array)
|
|
;; (define-extern *gun-course-info* array)
|
|
;; (define-extern *gungame-test-crates-pos* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; formations ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype formation-info (structure)
|
|
((composition basic :offset-assert 0)
|
|
(layout basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype formation-layout (basic)
|
|
((formation-points UNKNOWN 10 :offset-assert 16)
|
|
(num-formation-points int8 :offset-assert 176)
|
|
(leader-index int8 :offset-assert 177)
|
|
(__pad int16 :offset-assert 178)
|
|
(scale-factor float :offset-assert 180)
|
|
(estimated-radius float :offset-assert 184)
|
|
(composition basic :offset-assert 188)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xc0
|
|
:flag-assert #xa000000c0
|
|
(:methods
|
|
(formation-layout-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *formation-layout-cross* array)
|
|
;; (define-extern *formation-composition-cross* array)
|
|
;; (define-extern *formation-layout-wedge* array)
|
|
;; (define-extern *formation-composition-wedge* array)
|
|
;; (define-extern *formation-list* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; formation-object ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; handle-array is already defined!
|
|
|
|
#|
|
|
(deftype formation-object (process-focusable)
|
|
((object-list basic :offset-assert 208)
|
|
(num-objects int8 :offset-assert 212)
|
|
(formation basic :offset-assert 216)
|
|
(flags uint8 :offset-assert 220)
|
|
(controller vehicle-controller :inline :offset-assert 224)
|
|
(alert-time-offset uint64 :offset-assert 368)
|
|
(dest-position vector :inline :offset-assert 384)
|
|
(formation-transform matrix :inline :offset-assert 400)
|
|
)
|
|
:method-count-assert 48
|
|
:size-assert #x1d0
|
|
:flag-assert #x30015001d0
|
|
(:methods
|
|
(formation-object-method-30 () none) ;; 30
|
|
(formation-object-method-31 () none) ;; 31
|
|
(formation-object-method-32 () none) ;; 32
|
|
(formation-object-method-33 () none) ;; 33
|
|
(formation-object-method-34 () none) ;; 34
|
|
(formation-object-method-35 () none) ;; 35
|
|
(formation-object-method-36 () none) ;; 36
|
|
(formation-object-method-37 () none) ;; 37
|
|
(formation-object-method-38 () none) ;; 38
|
|
(formation-object-method-39 () none) ;; 39
|
|
(formation-object-method-40 () none) ;; 40
|
|
(formation-object-method-41 () none) ;; 41
|
|
(formation-object-method-42 () none) ;; 42
|
|
(formation-object-method-43 () none) ;; 43
|
|
(formation-object-method-44 () none) ;; 44
|
|
(formation-object-method-45 () none) ;; 45
|
|
(formation-object-method-46 () none) ;; 46
|
|
(formation-object-method-47 () none) ;; 47
|
|
)
|
|
(:state-methods
|
|
inactive ;; 29
|
|
active ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype msg-get-num-inactive (structure)
|
|
((obj-type uint8 :offset-assert 0)
|
|
(num-inactive-out int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype msg-get-inactive-objects (structure)
|
|
((object-type-info-array uint32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern formation-init-by-other function)
|
|
;; (define-extern foo-hack object)
|
|
;; (define-extern formation-object-event-handler function)
|
|
;; (define-extern random-var object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; civilian ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype civilian-anim-info (structure)
|
|
((anim-index int32 2 :offset-assert 0) ;; guessed by decompiler
|
|
(anim-index-front int32 :offset-assert 0)
|
|
(anim-index-back int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype civilian-global-info (basic)
|
|
((prev-yellow-hit int8 :offset-assert 4)
|
|
(prev-blue-hit int8 :offset-assert 5)
|
|
(knocked int32 2 :offset-assert 8) ;; guessed by decompiler
|
|
(anim-knocked-front int32 :offset-assert 8)
|
|
(anim-knocked-back int32 :offset-assert 12)
|
|
(knocked-land int32 2 :offset-assert 16) ;; guessed by decompiler
|
|
(anim-knocked-front-land int32 :offset-assert 16)
|
|
(anim-knocked-back-land int32 :offset-assert 20)
|
|
(yellow-hit-anim civilian-anim-info 1 :offset-assert 24) ;; guessed by decompiler
|
|
(blue-hit-anim civilian-anim-info 3 :offset-assert 32) ;; guessed by decompiler
|
|
(anim-cover-head-start int32 :offset-assert 56)
|
|
(anim-cover-head-loop int32 :offset-assert 60)
|
|
(anim-cover-head-end int32 :offset-assert 64)
|
|
(car-stance-anim int32 :offset-assert 68)
|
|
(bike-stance-anim int32 :offset-assert 72)
|
|
(get-in-car-anim int32 :offset-assert 76)
|
|
(get-on-bike-anim int32 :offset-assert 80)
|
|
(seat-flag uint8 :offset-assert 84)
|
|
(speech-ambient int8 :offset-assert 85)
|
|
(speech-alert int8 :offset-assert 86)
|
|
(speech-cower int8 :offset-assert 87)
|
|
(speech-touched-by-player int8 :offset-assert 88)
|
|
(speech-shot-by-player int8 :offset-assert 89)
|
|
(speech-avoiding-player-vehicle int8 :offset-assert 90)
|
|
(speech-hit-by-player-vehicle int8 :offset-assert 91)
|
|
(speech-player-stealing-vehicle int8 :offset-assert 92)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5d
|
|
:flag-assert #x90000005d
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype civilian (citizen)
|
|
((info civilian-global-info :offset-assert 1028) ;; guessed by decompiler
|
|
(anim-panic-run int32 :offset-assert 1032)
|
|
(anim-on-ground int32 :offset-assert 1036)
|
|
(anim-dive int32 :offset-assert 1040)
|
|
(anim-get-up-front int32 :offset-assert 1044)
|
|
(anim-get-up-back int32 :offset-assert 1048)
|
|
(last-second-pos vector :inline :offset-assert 1056)
|
|
(last-distance float :offset-assert 1072)
|
|
(next-time uint64 :offset-assert 1080) ;; time-frame
|
|
(dive-target-point vector :inline :offset-assert 1088)
|
|
(dive-reaction float :offset-assert 1104)
|
|
(allow-dive symbol :offset-assert 1108) ;; guessed by decompiler
|
|
(dive-finished? symbol :offset-assert 1112) ;; guessed by decompiler
|
|
(hit-face uint32 :offset-assert 1116)
|
|
(seat int32 :offset-assert 1120)
|
|
)
|
|
:method-count-assert 234
|
|
:size-assert #x464
|
|
:flag-assert #xea03f00464
|
|
(:methods
|
|
(civilian-method-229 () none) ;; 229
|
|
(civilian-method-230 () none) ;; 230
|
|
(civilian-method-231 () none) ;; 231
|
|
(civilian-method-232 () none) ;; 232
|
|
(civilian-method-233 () none) ;; 233
|
|
)
|
|
(:state-methods
|
|
cower-ground ;; 222
|
|
wait ;; 190
|
|
flee ;; 36
|
|
wait-at-dest ;; 228
|
|
knocked-recover ;; 32
|
|
move-to-vehicle ;; 224
|
|
avoid-danger ;; 216, old: (go-dive (_type_) none 216)
|
|
clear-path ;; 217, old: (civilian-method-217 (_type_ vector) symbol 217)
|
|
on-ground ;; 218
|
|
dive ;; 219
|
|
get-up-front ;; 220
|
|
get-up-back ;; 221
|
|
knocked ;; 31
|
|
wait-for-ride ;; 223
|
|
board-vehicle ;; 225
|
|
ride ;; 226
|
|
exit-vehicle ;; 227
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern civilian-flee-post function) ;; (function none :behavior civilian)
|
|
;; (define-extern civilian-avoid-danger-post function) ;; (function none :behavior civilian)
|
|
;; (define-extern civilian-avoid-danger-post2 function) ;; (function none :behavior civilian)
|
|
;; (define-extern civilian-clear-path-post function) ;; (function none :behavior civilian)
|
|
;; (define-extern civilian-clear-path-post2 function) ;; (function none :behavior civilian)
|
|
;; (define-extern civilian-falling-post function) ;; (function none :behavior civilian)
|
|
;; (define-extern do-spline2 function) ;; (function vector vector vector vector vector float vector)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; templex-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tpl-stone-break (process-drawable)
|
|
((spool-sound-id uint32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
drop ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spt-birth-func-brightness-part-temple-break-dust function)
|
|
;; (define-extern spt-birth-func-brightness-part-temple-break-dust-trail function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; turret-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype turret-barrel-info (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(local-dir vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype turret-control-info (structure)
|
|
((shot-type basic :offset-assert 0)
|
|
(joint-index int8 :offset-assert 4)
|
|
(barrel-count int8 :offset-assert 5)
|
|
(shot-speed float :offset-assert 8)
|
|
(attack-range float :offset-assert 12)
|
|
(damage float :offset-assert 16)
|
|
(vehicle-damage-factor float :offset-assert 20)
|
|
(vehicle-impulse-factor float :offset-assert 24)
|
|
(rot-min float 2 :offset-assert 28) ;; guessed by decompiler
|
|
(rot-max float 2 :offset-assert 36) ;; guessed by decompiler
|
|
(rot-x-min float :offset-assert 28)
|
|
(rot-x-max float :offset-assert 36)
|
|
(rot-y-min float :offset-assert 32)
|
|
(rot-y-max float :offset-assert 40)
|
|
(local-pos vector :inline :offset-assert 48)
|
|
(local-dir vector :inline :offset-assert 64)
|
|
(barrel-array turret-barrel-info 4 :offset-assert 80) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xd0
|
|
:flag-assert #x9000000d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype turret-control (structure)
|
|
((info turret-control-info :offset-assert 0)
|
|
(guard-settings squad-unit-settings :offset-assert 4) ;; traffic-guard-type-settings
|
|
(flags turret-flag :offset-assert 8)
|
|
(shot-count int8 :offset-assert 9)
|
|
(burst-count int16 :offset-assert 10)
|
|
(shot-delay uint16 :offset-assert 12)
|
|
(burst-delay uint16 :offset-assert 14)
|
|
(target-dist float :offset-assert 16)
|
|
(inaccuracy float :offset-assert 20)
|
|
(burst-delay-factor float :offset-assert 24)
|
|
(aim-offset-angle float :offset-assert 28) ;; degrees
|
|
(aim-rot float 2 :offset-assert 32) ;; guessed by decompiler
|
|
(aim-rot-vel float 2 :offset-assert 40) ;; guessed by decompiler
|
|
(aim-rot-offset float 2 :offset-assert 48) ;; guessed by decompiler
|
|
(aim-rot-x float :offset-assert 32)
|
|
(aim-rot-y float :offset-assert 36)
|
|
(aim-rot-vel-x float :offset-assert 40)
|
|
(aim-rot-vel-y float :offset-assert 44)
|
|
(target-in-sight-time uint64 :offset-assert 56) ;; time-frame
|
|
(aim-acquire-time uint64 :offset-assert 64) ;; time-frame
|
|
(shoot-time uint64 :offset-assert 72) ;; time-frame
|
|
(owner-handle uint64 :offset-assert 80) ;; handle
|
|
(ignore-handle uint64 :offset-assert 88)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x60
|
|
:flag-assert #x1200000060
|
|
;; field turret-flag is likely a value type.
|
|
(:methods
|
|
(turret-control-method-9 () none) ;; 9 ;; (turret-control-method-9 (_type_ vehicle vector vector) none 9)
|
|
(turret-control-method-10 () none) ;; 10 ;; (turret-control-method-10 (_type_ vehicle) none 10)
|
|
(turret-control-method-11 () none) ;; 11 ;; (turret-control-method-11 (_type_ object object vector) none 11)
|
|
(turret-control-method-12 () none) ;; 12 ;; (update-joint-mod (_type_ joint-mod-rotate-local) none 12)
|
|
(turret-control-method-13 () none) ;; 13 ;; (turret-control-method-13 (_type_) none 13)
|
|
(turret-control-method-14 () none) ;; 14 ;; (turret-control-method-14 (_type_) none 14)
|
|
(turret-control-method-15 () none) ;; 15 ;; (set-info (_type_ turret-control-info) none 15)
|
|
(turret-control-method-16 () none) ;; 16 ;; (turret-control-method-16 (_type_ float float) none 16)
|
|
(turret-control-method-17 () none) ;; 17 ;; (turret-control-method-17 (_type_ vehicle) none 17)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern vehicle-los-clear? function) ;; (function vector vector symbol)
|
|
;; (define-extern vehicle-draw-beam function) ;; (function sparticle-launcher vector vector object symbol none)
|
|
;; (define-extern vehicle-draw-laser-spot function) ;; (function vector vector symbol none)
|
|
;; (define-extern vehicle-draw-laser function) ;; (function vector vector none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; guard-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype guard-anim-info (structure)
|
|
((anim-index int32 2 :offset-assert 0) ;; guessed by decompiler
|
|
(anim-index-front int32 :offset-assert 0)
|
|
(anim-index-back int32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype guard-global-info (basic)
|
|
((prev-yellow-hit int8 :offset-assert 4)
|
|
(prev-blue-hit int8 :offset-assert 5)
|
|
(knocked int32 2 :offset-assert 8) ;; guessed by decompiler
|
|
(knocked-land int32 2 :offset-assert 16) ;; guessed by decompiler
|
|
(anim-knocked-front int32 :offset-assert 8)
|
|
(anim-knocked-back int32 :offset-assert 12)
|
|
(anim-knocked-front-land int32 :offset-assert 16)
|
|
(anim-knocked-back-land int32 :offset-assert 20)
|
|
(yellow-hit-anim guard-anim-info 2 :offset-assert 24) ;; guessed by decompiler
|
|
(yellow-land-anim guard-anim-info 2 :offset-assert 40) ;; guessed by decompiler
|
|
(blue-hit-anim int32 1 :offset-assert 56) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype guard-shoot-info (structure)
|
|
((anim-index int32 :offset-assert 0)
|
|
(start float :offset-assert 4)
|
|
(end float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype range (structure)
|
|
((start float :offset-assert 0)
|
|
(end float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype crimson-guard-collide-shape (collide-shape-moving)
|
|
()
|
|
:method-count-assert 68
|
|
:size-assert #x1dc
|
|
:flag-assert #x44000001dc
|
|
;; field penetrate is likely a value type. field penetrate is likely a value type.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype crimson-guard (citizen)
|
|
((info guard-global-info :offset-assert 1028) ;; guessed by decompiler
|
|
(hit-face uint32 :offset-assert 1032)
|
|
(anim-get-up-front int32 :offset-assert 1036)
|
|
(anim-get-up-back int32 :offset-assert 1040)
|
|
(small-hit int32 :offset-assert 1044)
|
|
(yellow-anim uint32 :offset-assert 1048)
|
|
(guard-type uint8 :offset-assert 1052)
|
|
(settings squad-unit-settings :offset-assert 1056) ;; traffic-guard-type-settings
|
|
(next-time uint64 :offset-assert 1064) ;; time-frame
|
|
(last-time-see-target uint64 :offset-assert 1072) ;; time-frame
|
|
(joint joint-mod :offset-assert 1080) ;; guessed by decompiler
|
|
(joint-enable symbol :offset-assert 1084) ;; guessed by decompiler
|
|
(already-shot symbol :offset-assert 1088) ;; guessed by decompiler
|
|
(miss-amount float :offset-assert 1092)
|
|
(l-control lightning-control :offset-assert 1096) ;; guessed by decompiler
|
|
(next-shot uint64 :offset-assert 1104) ;; int64
|
|
(anim-shoot guard-shoot-info 3 :offset-assert 1112) ;; guessed by decompiler
|
|
(transport uint64 :offset-assert 1152) ;; handle
|
|
(transport-side uint32 :offset-assert 1160)
|
|
(target-flags uint8 :offset-assert 1164)
|
|
(target-pos vector :inline :offset-assert 1168)
|
|
(target-pos-predict vector :inline :offset-assert 1184)
|
|
(target-pos-predict-miss vector :inline :offset-assert 1200)
|
|
(los-status uint64 :offset-assert 1216)
|
|
(target-vel-vec vector :inline :offset-assert 1232)
|
|
(target-vel float :offset-assert 1248)
|
|
(target-self vector :inline :offset-assert 1264)
|
|
(target-self-xz vector :inline :offset-assert 1280)
|
|
(target-self-dist float :offset-assert 1296)
|
|
(target-self-xz-dist float :offset-assert 1300)
|
|
(grenade-guard-min-player-dist float :offset-assert 1304)
|
|
(flee-behavior flee-info :inline :offset-assert 1308)
|
|
(last-check-player-time uint64 :offset-assert 1312)
|
|
(num-times-reloading-interrupted int32 :offset-assert 1320)
|
|
(total-flee-time uint64 :offset-assert 1328)
|
|
(last-fire-time uint64 :offset-assert 1336)
|
|
(ammo-count int8 :offset-assert 1344)
|
|
(urgent-fire basic :offset-assert 1348)
|
|
(last-onscreen-time uint64 :offset-assert 1352)
|
|
(target-y-angle float :offset-assert 1360) ;; degrees
|
|
(rand-state-time uint64 :offset-assert 1368)
|
|
(pursuit-start-time uint64 :offset-assert 1376)
|
|
(last-visible-target-pos vector :inline :offset-assert 1392)
|
|
(lazer-sound sound-id :offset-assert 1408) ;; guessed by decompiler
|
|
(move-position vector :inline :offset-assert 1424)
|
|
(move-index int32 :offset-assert 1440)
|
|
(reloading-ammo uint64 :offset-assert 1448)
|
|
(guard-riot-shield uint64 :offset-assert 1456)
|
|
(guard-shield-rotate-y-degrees float :offset-assert 1464)
|
|
(attack-hit-shield-type uint64 :offset-assert 1472)
|
|
(current-shield-logic uint64 :offset-assert 1480)
|
|
(target-status squad-target-status :inline :offset-assert 1488)
|
|
(minimap connection-minimap :offset-assert 1556)
|
|
(other-side symbol :offset-assert 1560) ;; guessed by decompiler
|
|
(last-choose-new-enemy-time uint64 :offset-assert 1568)
|
|
(last-quick-target-spot-angle float :offset-assert 1576)
|
|
(next-update-target-time uint64 :offset-assert 1584)
|
|
(last-player-attack-time uint64 :offset-assert 1592)
|
|
(player-attack-count int32 :offset-assert 1600)
|
|
)
|
|
:method-count-assert 291
|
|
:size-assert #x644
|
|
:flag-assert #x12305d00644
|
|
(:methods
|
|
(crimson-guard-method-216 () none) ;; 216 ;; (crimson-guard-method-216 (_type_) symbol 216)
|
|
(crimson-guard-method-217 () none) ;; 217 ;; (crimson-guard-method-217 (_type_ vector vector vector) int 217)
|
|
(crimson-guard-method-218 () none) ;; 218 ;; (crimson-guard-method-218 (_type_ vector) none 218)
|
|
(crimson-guard-method-219 () none) ;; 219 ;; (crimson-guard-method-219 (_type_) none 219)
|
|
(crimson-guard-method-220 () none) ;; 220 ;; (crimson-guard-method-220 (_type_) none 220)
|
|
(crimson-guard-method-221 () none) ;; 221 ;; (crimson-guard-method-221 (_type_) none 221)
|
|
(crimson-guard-method-222 () none) ;; 222 ;; (crimson-guard-method-222 (_type_) none 222)
|
|
(crimson-guard-method-223 () none) ;; 223 ;; (crimson-guard-method-223 (_type_ float) none 223)
|
|
(crimson-guard-method-224 () none) ;; 224 ;; (crimson-guard-method-224 (_type_ vector) float 224)
|
|
(crimson-guard-method-225 () none) ;; 225 ;; (crimson-guard-method-225 (_type_ uint symbol) none 225)
|
|
(crimson-guard-method-226 () none) ;; 226 ;; (crimson-guard-method-226 (_type_) none 226)
|
|
(crimson-guard-method-227 () none) ;; 227
|
|
(crimson-guard-method-228 () none) ;; 228
|
|
(crimson-guard-method-229 () none) ;; 229
|
|
(crimson-guard-method-230 () none) ;; 230
|
|
(crimson-guard-method-231 () none) ;; 231
|
|
(crimson-guard-method-232 () none) ;; 232
|
|
(crimson-guard-method-233 () none) ;; 233
|
|
(crimson-guard-method-234 () none) ;; 234
|
|
(crimson-guard-method-235 () none) ;; 235
|
|
(crimson-guard-method-236 () none) ;; 236
|
|
(crimson-guard-method-237 () none) ;; 237
|
|
(crimson-guard-method-238 () none) ;; 238
|
|
(crimson-guard-method-239 () none) ;; 239
|
|
(crimson-guard-method-240 () none) ;; 240
|
|
(crimson-guard-method-241 () none) ;; 241
|
|
(crimson-guard-method-242 () none) ;; 242
|
|
(crimson-guard-method-243 () none) ;; 243
|
|
(crimson-guard-method-244 () none) ;; 244
|
|
(crimson-guard-method-245 () none) ;; 245
|
|
(crimson-guard-method-246 () none) ;; 246
|
|
(crimson-guard-method-247 () none) ;; 247
|
|
(crimson-guard-method-248 () none) ;; 248
|
|
(crimson-guard-method-249 () none) ;; 249
|
|
(crimson-guard-method-250 () none) ;; 250
|
|
(crimson-guard-method-251 () none) ;; 251
|
|
(crimson-guard-method-252 () none) ;; 252
|
|
(crimson-guard-method-253 () none) ;; 253
|
|
(crimson-guard-method-254 () none) ;; 254
|
|
(crimson-guard-method-255 () none) ;; 255
|
|
(crimson-guard-method-256 () none) ;; 256
|
|
(crimson-guard-method-257 () none) ;; 257
|
|
(crimson-guard-method-258 () none) ;; 258
|
|
(crimson-guard-method-259 () none) ;; 259
|
|
(crimson-guard-method-260 () none) ;; 260
|
|
(crimson-guard-method-261 () none) ;; 261
|
|
(crimson-guard-method-262 () none) ;; 262
|
|
(crimson-guard-method-263 () none) ;; 263
|
|
(crimson-guard-method-264 () none) ;; 264
|
|
(crimson-guard-method-265 () none) ;; 265
|
|
(crimson-guard-method-266 () none) ;; 266
|
|
(crimson-guard-method-267 () none) ;; 267
|
|
(crimson-guard-method-268 () none) ;; 268
|
|
(crimson-guard-method-269 () none) ;; 269
|
|
(crimson-guard-method-270 () none) ;; 270
|
|
(crimson-guard-method-271 () none) ;; 271
|
|
(crimson-guard-method-272 () none) ;; 272
|
|
(crimson-guard-method-273 () none) ;; 273
|
|
(crimson-guard-method-274 () none) ;; 274
|
|
(crimson-guard-method-275 () none) ;; 275
|
|
(crimson-guard-method-276 () none) ;; 276
|
|
(crimson-guard-method-277 () none) ;; 277
|
|
(crimson-guard-method-278 () none) ;; 278
|
|
(crimson-guard-method-279 () none) ;; 279
|
|
(crimson-guard-method-280 () none) ;; 280
|
|
(crimson-guard-method-281 () none) ;; 281
|
|
(crimson-guard-method-282 () none) ;; 282
|
|
(crimson-guard-method-283 () none) ;; 283
|
|
(crimson-guard-method-284 () none) ;; 284
|
|
(crimson-guard-method-285 () none) ;; 285
|
|
(crimson-guard-method-286 () none) ;; 286
|
|
(crimson-guard-method-287 () none) ;; 287
|
|
(crimson-guard-method-288 () none) ;; 288
|
|
(crimson-guard-method-289 () none) ;; 289
|
|
(crimson-guard-method-290 () none) ;; 290
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; metalhead-grunt ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mh-grunt-anim-info (structure)
|
|
((anim-index int32 :offset-assert 0)
|
|
(travel-speed meters :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-grunt-global-info (basic)
|
|
((patrol-anim UNKNOWN 2 :offset-assert 4)
|
|
(charge-anim UNKNOWN 1 :offset-assert 20)
|
|
(attack-anim UNKNOWN 1 :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype metalhead-grunt (mh-squad-member)
|
|
((patrol-anim mh-grunt-anim-info :offset-assert 1080) ;; grunt-anim-info
|
|
(charge-anim mh-grunt-anim-info :offset-assert 1084) ;; grunt-anim-info
|
|
(attack-anim mh-grunt-anim-info :offset-assert 1088) ;; grunt-anim-info
|
|
(intro-path path-control :offset-assert 1092) ;; guessed by decompiler
|
|
(circle-radial-dist float :offset-assert 244)
|
|
(use-charge-anim-index int8 :offset-assert 1100)
|
|
(jumping-ambush-path-pt int8 :offset-assert 1101)
|
|
(mh-grunt-flags uint8 :offset-assert 1102)
|
|
(state-timeout2 uint64 :offset-assert 1104)
|
|
(next-warn-time uint64 :offset-assert 1112) ;; time-frame
|
|
(dest vector :inline :offset-assert 1120)
|
|
(focus-pos vector :inline :offset-assert 352)
|
|
)
|
|
:method-count-assert 231
|
|
:size-assert #x480
|
|
:flag-assert #xe704000480
|
|
(:methods
|
|
(metalhead-grunt-method-228 () none) ;; 228
|
|
(metalhead-grunt-method-229 () none) ;; 229
|
|
(metalhead-grunt-method-230 () none) ;; 230
|
|
)
|
|
(:state-methods
|
|
falling-ambush ;; 223
|
|
jumping-ambush ;; 224
|
|
knocked-recover ;; 32
|
|
jumping-ambush-cont ;; 225
|
|
active ;; 34
|
|
wait-for-focus ;; 226
|
|
stop-chase ;; 158
|
|
attack ;; 222
|
|
hostile ;; 38
|
|
spin-attack ;; 227
|
|
in-ditch ;; 192
|
|
die-fast ;; 42
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-mh-grunt-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *metalhead-grunt-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern *mh-grunt-global-info* mh-grunt-global-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; traffic-util ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern add-debug-line-arrow function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; traffic-engine ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype traffic-find-segment-struct (structure)
|
|
((best-seg nav-segment :offset-assert 0)
|
|
(best-rating float :offset-assert 4)
|
|
(dir vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *traffic-suppress-activation* object) ;; symbol
|
|
;; (define-extern get-level-nav-graph-by-id function) ;; (function int nav-graph)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; waspala-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-color-waspala-wallfire-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-waspala-wallfire-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-waspala-wallfire-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-waspala-wallfire-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-waspala-wallfire-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-waspala-wallfire-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-waspala-wallfire-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-waspala-wallfire-flame* curve2d-fast)
|
|
;; (define-extern *curve-waspala-wallfire-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-waspala-wallfire-flame-y* curve2d-fast)
|
|
;; (define-extern *part-waspala-wallfire-flame-curve-settings* object)
|
|
;; (define-extern *range-color-waspala-hanging-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-waspala-hanging-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-waspala-hanging-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-waspala-hanging-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-waspala-hanging-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-waspala-hanging-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-waspala-hanging-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-waspala-hanging-flame* curve2d-fast)
|
|
;; (define-extern *curve-waspala-hanging-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-waspala-hanging-flame-y* curve2d-fast)
|
|
;; (define-extern *part-waspala-hanging-flame-curve-settings* object)
|
|
;; (define-extern *range-color-waspala-crucible-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-waspala-crucible-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-waspala-crucible-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-waspala-crucible-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-waspala-crucible-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-waspala-crucible-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-waspala-crucible-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-waspala-crucible-flame* curve2d-fast)
|
|
;; (define-extern *curve-waspala-crucible-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-waspala-crucible-flame-y* curve2d-fast)
|
|
;; (define-extern *part-waspala-crucible-flame-curve-settings* object)
|
|
;; (define-extern *range-intro-waspala-squeeze-color* curve-color-fast)
|
|
;; (define-extern *range-intro-waspala-squeeze-alpha* curve2d-fast)
|
|
;; (define-extern *range-intro-waspala-squeeze-scale-x* curve2d-fast)
|
|
;; (define-extern *range-intro-waspala-squeeze-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-intro-waspala-squeeze-alpha* curve2d-fast)
|
|
;; (define-extern *curve-intro-waspala-squeeze-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-intro-waspala-squeeze-scale-y* curve2d-fast)
|
|
;; (define-extern *part-waspala-squeeze-water-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; traffic-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype traffic-manager (process)
|
|
((traffic-engine traffic-engine :offset-assert 128) ;; guessed by decompiler
|
|
(fast-spawn symbol :offset-assert 132) ;; guessed by decompiler
|
|
(dark-guard-ratio int32 :offset-assert 136)
|
|
(spawn-params traffic-object-spawn-params :inline :offset-assert 144)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x104
|
|
:flag-assert #x1700900104
|
|
(:methods
|
|
(traffic-manager-method-16 () none) ;; 16 ;; (update (_type_) none 16)
|
|
(traffic-manager-method-17 () none) ;; 17 ;; (spawn-all (_type_) none 17)
|
|
(traffic-manager-method-18 () none) ;; 18 ;; (kill-excess-once (_type_) none 18)
|
|
(traffic-manager-method-19 () none) ;; 19 ;; (kill-all-inactive (_type_) none 19)
|
|
(traffic-manager-method-20 () none) ;; 20 ;; (reset-and-init (_type_) none 20)
|
|
(traffic-manager-method-21 () none) ;; 21 ;; (init-params (_type_) none 21)
|
|
(traffic-manager-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 14, old: (idle () _type_ :state 14)
|
|
active ;; 15, old: (active () _type_ :state 15)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype want-count-binding (structure)
|
|
((obj-type uint8 :offset-assert 0)
|
|
(count uint8 :offset-assert 1)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype want-count-group (structure)
|
|
((bindings basic :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype want-count-level-group (structure)
|
|
((want-groups basic :offset-assert 0)
|
|
(level uint8 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5
|
|
:flag-assert #x900000005
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *traffic-engine* object) ;; traffic-engine
|
|
;; (define-extern *traffic-fast-spawn* object) ;; symbol
|
|
;; (define-extern draw-city-info function) ;; (function city-level-info vis-grid-pos none)
|
|
;; (define-extern formation-spawn function)
|
|
;; (define-extern type-from-traffic-object-type function)
|
|
;; (define-extern citizen-spawn function) ;; (function process type traffic-object-spawn-params process-drawable)
|
|
;; (define-extern traffic-object-spawn function) ;; (function process traffic-object-spawn-params process-drawable)
|
|
;; (define-extern *traffic-vehicle-level-borrow-list* object)
|
|
;; (define-extern *traffic-vehicle-level-sound-list* object)
|
|
;; (define-extern traffic-manager-event-handler function) ;; (function process int symbol event-message-block object :behavior traffic-manager)
|
|
;; (define-extern traffic-manager-init-by-other function) ;; (function none :behavior traffic-manager)
|
|
;; (define-extern traffic-start function) ;; (function none)
|
|
;; (define-extern traffic-kill function) ;; (function none)
|
|
;; (define-extern ctywide-entity-hack function) ;; (function none)
|
|
;; (define-extern traffic-entity-hack function)
|
|
;; (define-extern riders-on function) ;; (function none)
|
|
;; (define-extern riders-off function) ;; (function none)
|
|
;; (define-extern *want-count-levels* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-rescue ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rescue-speech-instance (speech-instance)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-rescue-transport-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(path-pts uint32 :offset-assert 32)
|
|
(num-pts int32 :offset-assert 36)
|
|
(desresc-path basic :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-passenger-info (structure)
|
|
((passenger-pos vector :inline :offset-assert 0)
|
|
(beacon-pos vector :inline :offset-assert 16)
|
|
(transport-angle float :offset-assert 32)
|
|
(is-final? basic :offset-assert 36)
|
|
(total-time uint64 :offset-assert 40)
|
|
(num-marauders int8 :offset-assert 48)
|
|
(sandstorm-intensity float :offset-assert 52)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-rescue (task-manager)
|
|
((current-passenger-index int8 :offset-assert 240)
|
|
(current-passenger uint64 :offset-assert 248)
|
|
(current-task-arrow uint64 :offset-assert 256)
|
|
(current-transport uint64 :offset-assert 264)
|
|
(taxi-timer uint64 :offset-assert 272)
|
|
(num-enemies-remaining int8 :offset-assert 288)
|
|
(current-enemy uint64 :offset-assert 296)
|
|
(jak-vehicle uint64 :offset-assert 304)
|
|
(dust-storm uint64 :offset-assert 312)
|
|
(passenger-pos basic :offset-assert 320)
|
|
(desresc-path basic :offset-assert 324)
|
|
)
|
|
:method-count-assert 50
|
|
:size-assert #x148
|
|
:flag-assert #x3200d00148
|
|
(:methods
|
|
(task-manager-desert-rescue-method-42 () none) ;; 42
|
|
(task-manager-desert-rescue-method-43 () none) ;; 43
|
|
(task-manager-desert-rescue-method-44 () none) ;; 44
|
|
(task-manager-desert-rescue-method-45 () none) ;; 45
|
|
(task-manager-desert-rescue-method-46 () none) ;; 46
|
|
(task-manager-desert-rescue-method-47 () none) ;; 47
|
|
(task-manager-desert-rescue-method-48 () none) ;; 48
|
|
(task-manager-desert-rescue-method-49 () none) ;; 49
|
|
)
|
|
(:state-methods
|
|
play-dead-wlander-movie ;; 38
|
|
wait ;; 14
|
|
wait-for-vehicle-return ;; 39
|
|
active ;; 15
|
|
rescue-start ;; 37
|
|
race-home ;; 36
|
|
investigate-dead-wlander ;; 40
|
|
fight ;; 35
|
|
pickup-passenger ;; 32
|
|
drop-off-passenger ;; 33
|
|
finish-task ;; 34
|
|
fail-delay ;; 41
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype transport-path-control (path-control)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #x24
|
|
:flag-assert #x2000000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-rescue-transport (process-focusable)
|
|
((pitch float :offset-assert 208)
|
|
(target-pitch float :offset-assert 212)
|
|
(down-force float :offset-assert 216)
|
|
(ground-offset float :offset-assert 220)
|
|
(offset-dist float :offset-assert 224)
|
|
(angular-speed float :offset-assert 228)
|
|
(path-t float :offset-assert 232)
|
|
(current-node-index int16 :offset-assert 236)
|
|
(current-stop-node-index int16 :offset-assert 238)
|
|
(move-speed float :offset-assert 240)
|
|
(target-move-speed float :offset-assert 244)
|
|
(has-passenger? basic :offset-assert 248)
|
|
(seek-speed float :offset-assert 252)
|
|
(is-braking? basic :offset-assert 256)
|
|
(teleport-when-ready? basic :offset-assert 260)
|
|
(die-when-ready? basic :offset-assert 264)
|
|
(is-last-passenger? basic :offset-assert 268)
|
|
(tread1 uint64 :offset-assert 272)
|
|
(tread2 uint64 :offset-assert 280)
|
|
(tread-frequency uint8 :offset-assert 288)
|
|
(tread-last-spawn-index uint8 :offset-assert 289)
|
|
(desresc-path basic :offset-assert 292)
|
|
(can-board? basic :offset-assert 296)
|
|
)
|
|
:method-count-assert 46
|
|
:size-assert #x12c
|
|
:flag-assert #x2e00b0012c
|
|
(:methods
|
|
(desert-rescue-transport-method-28 () none) ;; 28
|
|
(desert-rescue-transport-method-30 () none) ;; 30
|
|
(desert-rescue-transport-method-34 () none) ;; 34
|
|
(desert-rescue-transport-method-35 () none) ;; 35
|
|
(desert-rescue-transport-method-36 () none) ;; 36
|
|
(desert-rescue-transport-method-37 () none) ;; 37
|
|
(desert-rescue-transport-method-38 () none) ;; 38
|
|
(desert-rescue-transport-method-39 () none) ;; 39
|
|
(desert-rescue-transport-method-40 () none) ;; 40
|
|
(desert-rescue-transport-method-41 () none) ;; 41
|
|
(desert-rescue-transport-method-42 () none) ;; 42
|
|
(desert-rescue-transport-method-43 () none) ;; 43
|
|
(desert-rescue-transport-method-44 () none) ;; 44
|
|
(desert-rescue-transport-method-45 () none) ;; 45
|
|
)
|
|
(:state-methods
|
|
die ;; 29
|
|
preparing-for-launch ;; 33
|
|
waiting-for-passenger ;; 32
|
|
following-path ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *desert-rescue-speech-list* object)
|
|
;; (define-extern *rescue-speech* array)
|
|
;; (define-extern *rescue-speech-1* array)
|
|
;; (define-extern *rescue-speech-2* array)
|
|
;; (define-extern *rescue-speech-array* array)
|
|
;; (define-extern *duststorm-gate-pos* object)
|
|
;; (define-extern *duststorm-wind-angle* object)
|
|
;; (define-extern *home-pos* object)
|
|
;; (define-extern *snake-start-pos* object)
|
|
;; (define-extern *snake-start-angle* object)
|
|
;; (define-extern *passenger-pos* array)
|
|
;; (define-extern *__transport-path__* object)
|
|
;; (define-extern *transport-tread-settings* object)
|
|
;; (define-extern *replace-last* object)
|
|
;; (define-extern *frequency* object)
|
|
;; (define-extern desert-transport-event-handler function)
|
|
;; (define-extern desert-rescue-transport-init-by-other function)
|
|
;; (define-extern *transport-move-speed* object)
|
|
;; (define-extern idle-hidden state)
|
|
;; (define-extern hidden-idle state)
|
|
;; (define-extern *nav-mesh-aid* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-rescue-bbush ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-desert-rescue-bbush (task-manager-desert-rescue)
|
|
((actor-group uint32 :offset-assert 324)
|
|
(actor-group-count int32 :offset-assert 328)
|
|
(final-timeout uint64 :offset-assert 332)
|
|
)
|
|
:method-count-assert 52
|
|
:size-assert #x158
|
|
:flag-assert #x3400e00158
|
|
(:state-methods
|
|
active ;; 15
|
|
drop-off-passenger ;; 33
|
|
show-finish ;; 50
|
|
finish-bbush ;; 51
|
|
pickup-passenger ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *bbush-passenger-pos* object)
|
|
;; (define-extern *__bbush-transport-path__* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hvehicle-effects ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wland-passenger ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wland-passenger (citizen)
|
|
((task-arrow uint64 :offset-assert 1032)
|
|
(start-pos vector :inline :offset-assert 1040)
|
|
(seat int32 :offset-assert 1056)
|
|
(transport uint64 :offset-assert 1064)
|
|
(is-dead? basic :offset-assert 1072)
|
|
(align basic :offset-assert 148)
|
|
(front-back-interp float :offset-assert 1080)
|
|
(left-right-interp float :offset-assert 1084)
|
|
(up-down-interp float :offset-assert 1088)
|
|
(original-trans vector :inline :offset-assert 1104)
|
|
(desired-pos vector :inline :offset-assert 1120)
|
|
(dest-quat quaternion :inline :offset-assert 1136)
|
|
(original-quat quaternion :inline :offset-assert 1152)
|
|
(backup-nav-mask uint32 :offset-assert 1168)
|
|
(task-man uint64 :offset-assert 1176)
|
|
(nav-sphere-handle uint64 :offset-assert 1184)
|
|
)
|
|
:method-count-assert 232
|
|
:size-assert #x4a8
|
|
:flag-assert #xe8043004a8
|
|
(:methods
|
|
(wland-passenger-method-226 () none) ;; 226
|
|
(wland-passenger-method-227 () none) ;; 227
|
|
(wland-passenger-method-228 () none) ;; 228
|
|
(wland-passenger-method-229 () none) ;; 229
|
|
(wland-passenger-method-230 () none) ;; 230
|
|
(wland-passenger-method-231 () none) ;; 231
|
|
)
|
|
(:state-methods
|
|
entering-transport ;; 222
|
|
returning ;; 217
|
|
wait-for-transport-to-open ;; 225
|
|
approaching-transport ;; 221
|
|
boarding ;; 216
|
|
board-vehicle ;; 218
|
|
exit-vehicle ;; 220
|
|
ride ;; 219
|
|
ride-start ;; 224
|
|
lying-prone ;; 223
|
|
active ;; 34
|
|
inactive ;; 191
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wland-passenger-init-by-other-params (traffic-object-spawn-params)
|
|
((nav-branch nav-branch :offset-assert 24)
|
|
(is-dead? basic :offset-assert 116)
|
|
(parent uint64 :offset-assert 120)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x80
|
|
:flag-assert #x900000080
|
|
)
|
|
|#
|
|
|
|
;; (define-extern probe-for-transport-ground function)
|
|
;; (define-extern compute-y-height function)
|
|
;; (define-extern compute-transport-approach-pt function)
|
|
;; (define-extern update-nav-sphere function)
|
|
;; (define-extern do-spline3 function)
|
|
;; (define-extern *progress* object)
|
|
;; (define-extern wland-passenger-wcar-anim-loop function)
|
|
;; (define-extern wland-passenger-init-by-other function)
|
|
;; (define-extern *wland-passenger-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern spawn-wlander function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-dummy ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tpath-control-frame (structure)
|
|
((time float :offset-assert 0)
|
|
(path-pos uint8 :offset-assert 4)
|
|
(command uint8 :offset-assert 5) ;; tpath-command
|
|
(move-type uint8 :offset-assert 6)
|
|
(path-num uint8 :offset-assert 7)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpath-info (structure)
|
|
((s-time float :offset-assert 0)
|
|
(num uint16 :offset-assert 4)
|
|
(ref-time-num int16 :offset-assert 6)
|
|
(score int16 :offset-assert 8)
|
|
(flags uint16 :offset-assert 10) ;; tpath-flags
|
|
(num-anims uint8 :offset-assert 12)
|
|
(bonus-time float :offset-assert 16)
|
|
(list (array int32) :offset-assert 20) ;; guessed by decompiler
|
|
(anims (inline-array tpath-control-frame) 3 :offset-assert 24) ;; guessed by decompiler
|
|
(anim1 (inline-array tpath-control-frame) :offset-assert 24) ;; guessed by decompiler
|
|
(anim2 (inline-array tpath-control-frame) :offset-assert 28) ;; guessed by decompiler
|
|
(anim3 (inline-array tpath-control-frame) :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-gun-info (structure)
|
|
((gun-state uint8 :offset-assert 0)
|
|
(joint-index int16 :offset-assert 2)
|
|
(trans vector :inline :offset-assert 16)
|
|
(quat quaternion :inline :offset-assert 32)
|
|
(next-fire-time uint64 :offset-assert 48)
|
|
(total-rotation float :offset-assert 56)
|
|
(current-rotation float :offset-assert 60)
|
|
(last-track-player-time uint64 :offset-assert 64)
|
|
(last-known-player-pos vector :inline :offset-assert 80)
|
|
(fire-speed-scalar float :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x64
|
|
:flag-assert #x900000064
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy (process-focusable)
|
|
((incoming-attack-id uint32 :offset-assert 208)
|
|
(incoming-attack-id-time uint64 :offset-assert 216)
|
|
(train-man uint64 :offset-assert 224) ;; handle
|
|
(info tpath-info :offset-assert 232)
|
|
(y-offset float :offset-assert 236)
|
|
(rot-y-offset float :offset-assert 240)
|
|
(quat quaternion :inline :offset-assert 256)
|
|
(hit-points int32 :offset-assert 272)
|
|
(score float :offset-assert 276)
|
|
(path-num uint32 :offset-assert 280)
|
|
(next-spark uint64 :offset-assert 288) ;; int64
|
|
(inout-percent float :offset-assert 296)
|
|
(quat-ground quaternion :inline :offset-assert 304)
|
|
(path-pos float :offset-assert 320)
|
|
(score-speed float :offset-assert 324)
|
|
(first-time-command symbol :offset-assert 328) ;; guessed by decompiler
|
|
(current tpath-control-frame :offset-assert 332) ;; (inline-array tpath-control-frame)
|
|
(impact vector :inline :offset-assert 336)
|
|
(done? symbol :offset-assert 352) ;; guessed by decompiler
|
|
(move-sound sound-id :offset-assert 356) ;; guessed by decompiler
|
|
(turn-sound sound-id :offset-assert 360) ;; guessed by decompiler
|
|
(spin-sound sound-id :offset-assert 364) ;; guessed by decompiler
|
|
(last-combo-time uint64 :offset-assert 368) ;; time-frame
|
|
(gun-info gun-dummy-gun-info :inline :offset-assert 384)
|
|
(joint-exploder basic :offset-assert 484)
|
|
(joint-explode-skel-group basic :offset-assert 488)
|
|
(joint-explode-anim-index int16 :offset-assert 492)
|
|
(hum-sound uint32 :offset-assert 496)
|
|
(explode-part-group basic :offset-assert 500)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x1f8
|
|
:flag-assert #x26018001f8
|
|
(:methods
|
|
(gun-dummy-method-29 () none) ;; 29 ;; (path-playing? (_type_) symbol 29)
|
|
(gun-dummy-method-30 () none) ;; 30 ;; (path-time-elapsed (_type_) float 30)
|
|
(gun-dummy-method-31 () none) ;; 31 ;; (init-tpath-info! (_type_ tpath-info) none 31)
|
|
(gun-dummy-method-32 () none) ;; 32 ;; (break-dummy (_type_) none 32)
|
|
(gun-dummy-method-33 () none) ;; 33
|
|
(gun-dummy-method-34 () none) ;; 34
|
|
(gun-dummy-method-35 () none) ;; 35
|
|
(gun-dummy-method-36 () none) ;; 36
|
|
(gun-dummy-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
idle ;; 28, old: (init-dummy-collison! (_type_) none 28)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-gun (gun-dummy)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
(:methods
|
|
(gun-dummy-gun-method-38 () none) ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-base (gun-dummy)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
(:methods
|
|
(gun-dummy-base-method-38 () none) ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-explode (gun-dummy)
|
|
((arm-start-time uint64 :offset-assert 504)
|
|
(explode-start-time uint64 :offset-assert 504)
|
|
(explode-delay uint64 :offset-assert 512)
|
|
(exploded? basic :offset-assert 520)
|
|
(last-flash-val float :offset-assert 524)
|
|
)
|
|
:method-count-assert 39
|
|
:size-assert #x210
|
|
:flag-assert #x2701900210
|
|
(:state-methods
|
|
idle ;; 28
|
|
explode ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-kg-b (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-rc-two-eyes (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-rc-one-eye (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-rc-three-eyes (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-kg-c (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-kg-big (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-rc-four-eyes (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-kg-bonus (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-rc-three-eyes-bonus (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-cit-a (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-cit-b (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-cit-c (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-cit-d (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-cit-ratchet (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-dummy-cit-clank (gun-dummy-base)
|
|
()
|
|
:method-count-assert 39
|
|
:size-assert #x1f8
|
|
:flag-assert #x27018001f8
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *gungame-level* object)
|
|
;; (define-extern *tpath-rand* object) ;; uint
|
|
;; (define-extern generate-next-fire-time function)
|
|
;; (define-extern gun-dummy-event-handler function)
|
|
;; (define-extern gun-dummy-gun-aim-jmod-func function)
|
|
;; (define-extern gun-dummy-gun-init-by-other function)
|
|
;; (define-extern gun-dummy-base-init-by-other function)
|
|
;; (define-extern gun-dummy-explode-init-by-other function)
|
|
;; (define-extern *dummy-flash-counters* array)
|
|
;; (define-extern spawn-dummy-projectile function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rope-system-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rope-knot (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(prev-pos vector :inline :offset-assert 16)
|
|
(force vector :inline :offset-assert 32)
|
|
(mass float :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-knot-constraint (structure)
|
|
((dir vector :inline :offset-assert 0)
|
|
(length float :offset-assert 16)
|
|
(max-angle float :offset-assert 20)
|
|
(rest-seek-rate float :offset-assert 24)
|
|
(constrained-angle-time uint64 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-knot-constraint-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-knot-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-system (basic)
|
|
((knots basic :offset-assert 4)
|
|
(knot-constraints basic :offset-assert 8)
|
|
(accum-force vector :inline :offset-assert 16)
|
|
(gravity float :offset-assert 32)
|
|
(gravity-dir vector :inline :offset-assert 48)
|
|
(drag float :offset-assert 64)
|
|
(flags uint64 :offset-assert 72)
|
|
(angular-mass-seek-rate float :offset-assert 80)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x54
|
|
:flag-assert #x1800000054
|
|
(:methods
|
|
(rope-system-method-9 () none) ;; 9
|
|
(rope-system-method-10 () none) ;; 10
|
|
(rope-system-method-11 () none) ;; 11
|
|
(rope-system-method-12 () none) ;; 12
|
|
(rope-system-method-13 () none) ;; 13
|
|
(rope-system-method-14 () none) ;; 14
|
|
(rope-system-method-15 () none) ;; 15
|
|
(rope-system-method-16 () none) ;; 16
|
|
(rope-system-method-17 () none) ;; 17
|
|
(rope-system-method-18 () none) ;; 18
|
|
(rope-system-method-19 () none) ;; 19
|
|
(rope-system-method-20 () none) ;; 20
|
|
(rope-system-method-21 () none) ;; 21
|
|
(rope-system-method-22 () none) ;; 22
|
|
(rope-system-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-joint-info (structure)
|
|
((joint-index int16 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2
|
|
:flag-assert #x900000002
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-joint-system-info (structure)
|
|
((joint-info-array basic :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype joint-mod-world-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rope-system ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prebot-eco-creature ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype prebot-large-eco-creature (nav-enemy)
|
|
((old-y-deg float :offset-assert 620)
|
|
(diff-angle float :offset-assert 624)
|
|
(attack-anims basic :offset-assert 628)
|
|
(victory-anims basic :offset-assert 632)
|
|
(turn-left-anim int32 :offset-assert 636)
|
|
(turn-right-anim int32 :offset-assert 640)
|
|
(split-type basic :offset-assert 644)
|
|
(attack-stop-frame float :offset-assert 648)
|
|
(traj trajectory :inline :offset-assert 656)
|
|
(which-trajectory int8 :offset-assert 696)
|
|
(x-rotate float :offset-assert 700)
|
|
(y-rotate float :offset-assert 704)
|
|
(launch-pos vector :inline :offset-assert 720)
|
|
(launch vector :inline :offset-assert 736)
|
|
(spin-jm basic :offset-assert 752)
|
|
(trail-part basic :offset-assert 756)
|
|
(trail-sound uint32 :offset-assert 760)
|
|
(flags uint64 :offset-assert 768)
|
|
)
|
|
:method-count-assert 196
|
|
:size-assert #x308
|
|
:flag-assert #xc402900308
|
|
(:methods
|
|
(prebot-large-eco-creature-method-194 () none) ;; 194
|
|
(prebot-large-eco-creature-method-195 () none) ;; 195
|
|
)
|
|
(:state-methods
|
|
knocked ;; 31
|
|
wait-for-children ;; 193
|
|
attack ;; 192
|
|
notice ;; 35
|
|
hostile ;; 38
|
|
stare ;; 37
|
|
circling ;; 157
|
|
pacing ;; 156
|
|
victory ;; 39
|
|
unfold ;; 190
|
|
fly-to-dest ;; 191
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-medium-eco-creature (prebot-large-eco-creature)
|
|
((is-top basic :offset-assert 776)
|
|
(is-bottom basic :offset-assert 780)
|
|
(initial-scale float :offset-assert 784)
|
|
(final-scale float :offset-assert 788)
|
|
)
|
|
:method-count-assert 198
|
|
:size-assert #x318
|
|
:flag-assert #xc602a00318
|
|
(:methods
|
|
(prebot-medium-eco-creature-method-196 () none) ;; 196
|
|
(prebot-medium-eco-creature-method-197 () none) ;; 197
|
|
)
|
|
(:state-methods
|
|
knocked-recover ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prebot-small-eco-creature (prebot-medium-eco-creature)
|
|
()
|
|
:method-count-assert 198
|
|
:size-assert #x318
|
|
:flag-assert #xc602a00318
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype medium-eco-creature-launched (prebot-medium-eco-creature)
|
|
()
|
|
:method-count-assert 198
|
|
:size-assert #x318
|
|
:flag-assert #xc602a00318
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype small-eco-creature-launched (prebot-small-eco-creature)
|
|
()
|
|
:method-count-assert 198
|
|
:size-assert #x318
|
|
:flag-assert #xc602a00318
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype large-eco-creature (prebot-large-eco-creature)
|
|
()
|
|
:method-count-assert 196
|
|
:size-assert #x308
|
|
:flag-assert #xc402900308
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype medium-eco-creature (prebot-medium-eco-creature)
|
|
()
|
|
:method-count-assert 198
|
|
:size-assert #x318
|
|
:flag-assert #xc602a00318
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype small-eco-creature (prebot-small-eco-creature)
|
|
()
|
|
:method-count-assert 198
|
|
:size-assert #x318
|
|
:flag-assert #xc602a00318
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *prebot-large-eco-creature-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern large-eco-creature-split function)
|
|
;; (define-extern *prebot-medium-eco-creature-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern prebot-eco-creature-joint-callback function)
|
|
;; (define-extern adjust-split-joints function)
|
|
;; (define-extern *prebot-small-eco-creature-nav-enemy-info* nav-enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rope-prim-system-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rope-joint-system (rope-system)
|
|
((info rope-joint-system-info :offset-assert 84)
|
|
(joint-mods basic :offset-assert 88)
|
|
(proc uint64 :offset-assert 96)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x68
|
|
:flag-assert #x1900000068
|
|
(:methods
|
|
(rope-joint-system-method-24 () none) ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rope-prim-system (rope-system)
|
|
((strip1 basic :offset-assert 84)
|
|
(strip2 basic :offset-assert 88)
|
|
(width float :offset-assert 92)
|
|
(alpha float :offset-assert 96)
|
|
(uv-repeat-dist float :offset-assert 100)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x68
|
|
:flag-assert #x1900000068
|
|
(:methods
|
|
(rope-prim-system-method-24 () none) ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-effects ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wvehicle-wheel-launcher-spec (structure)
|
|
((mat matrix :offset-assert 0)
|
|
(particle-system basic :offset-assert 4)
|
|
(launcher basic :offset-assert 8)
|
|
(num-spec sp-field-init-spec :offset-assert 12)
|
|
(r-spec sp-field-init-spec :offset-assert 16)
|
|
(g-spec sp-field-init-spec :offset-assert 20)
|
|
(b-spec sp-field-init-spec :offset-assert 24)
|
|
(a-spec sp-field-init-spec :offset-assert 28)
|
|
(scale-x-spec sp-field-init-spec :offset-assert 32)
|
|
(scale-y-spec sp-field-init-spec :offset-assert 36)
|
|
(fade-a-spec sp-field-init-spec :offset-assert 40)
|
|
(ptr-birth-accum uint32 :offset-assert 44)
|
|
(i-birth-accum int8 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x31
|
|
:flag-assert #x900000031
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wvehicle-part-work (structure)
|
|
((local-mat matrix :inline :offset-assert 0)
|
|
(world-mat matrix :inline :offset-assert 64)
|
|
(velocity vector :inline :offset-assert 128)
|
|
(side-dir vector :inline :offset-assert 144)
|
|
(up-dir vector :inline :offset-assert 160)
|
|
(forward-dir vector :inline :offset-assert 176)
|
|
(wheel-axis vector :inline :offset-assert 192)
|
|
(surface-pos vector :inline :offset-assert 208)
|
|
(part-vel vector :inline :offset-assert 224)
|
|
(pos-l vector :inline :offset-assert 240)
|
|
(pos-r vector :inline :offset-assert 256)
|
|
(offset vector :inline :offset-assert 272)
|
|
(zero-offset vector :inline :offset-assert 288)
|
|
(prev-pos vector :inline :offset-assert 304)
|
|
(surface-type uint8 :offset-assert 320)
|
|
(wheel-rev-speed float :offset-assert 324)
|
|
(wheel-speed float :offset-assert 328)
|
|
(wheel-radius float :offset-assert 332)
|
|
(wheel-width float :offset-assert 336)
|
|
(part-num float :offset-assert 340)
|
|
(rand-val float :offset-assert 344)
|
|
(scale float :offset-assert 348)
|
|
(slip float :offset-assert 352)
|
|
(up-force float :offset-assert 356)
|
|
(alpha float :offset-assert 360)
|
|
(alpha-range float :offset-assert 364)
|
|
(vel-scale float :offset-assert 368)
|
|
(cur-time uint32 :offset-assert 372)
|
|
(ups float :offset-assert 376)
|
|
(dirt-launcher wvehicle-wheel-launcher-spec :inline :offset-assert 380)
|
|
(dust-launcher wvehicle-wheel-launcher-spec :inline :offset-assert 432)
|
|
(spray-launcher wvehicle-wheel-launcher-spec :inline :offset-assert 484)
|
|
(ripple-launcher wvehicle-wheel-launcher-spec :inline :offset-assert 536)
|
|
(dummy-spec sp-field-init-spec :inline :offset-assert 588)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x25c
|
|
:flag-assert #x90000025c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tire-trail-crumb (light-trail-breadcrumb)
|
|
((offset vector :inline :offset-assert 16)
|
|
(uu float :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tire-trail (light-trail)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #x80
|
|
:flag-assert #x1800000080
|
|
(:methods
|
|
(tire-trail-method-22 () none) ;; 22
|
|
(tire-trail-method-23 () none) ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tire-trail-tracker (light-trail-tracker)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xac
|
|
:flag-assert #x15003000ac
|
|
(:state-methods
|
|
tracking ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wvehicle-sound-loop-params (structure)
|
|
((speed float :offset-assert 0)
|
|
(weight float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wvehicle-sound-work (structure)
|
|
((roll-basis-params UNKNOWN 4 :offset-assert 0)
|
|
(slide-basis-params UNKNOWN 2 :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *wheel-trail-info* object)
|
|
;; (define-extern tire-trail-tracker-init-by-other function)
|
|
;; (define-extern spawn-tire-trail-tracker function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; railx-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype railx-states (structure)
|
|
((pulses UNKNOWN 6 :offset-assert 0)
|
|
(blue pulse-state :inline :offset-assert 0)
|
|
(yellow pulse-state :inline :offset-assert 16)
|
|
(warp pulse-state :inline :offset-assert 32)
|
|
(spill pulse-state :inline :offset-assert 48)
|
|
(egg pulse-state :inline :offset-assert 64)
|
|
(transform pulse-state :inline :offset-assert 80)
|
|
(flicker float :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x64
|
|
:flag-assert #x900000064
|
|
)
|
|
|#
|
|
|
|
;; (define-extern init-mood-railx function)
|
|
;; (define-extern update-railx-lights function)
|
|
;; (define-extern update-mood-railx function)
|
|
;; (define-extern set-railx-light-brightness! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; templex-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype templex-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-templex-lights function)
|
|
;; (define-extern update-mood-templex function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-fox ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-fox (wcar-snake-base)
|
|
()
|
|
:method-count-assert 203
|
|
:size-assert #xd60
|
|
:flag-assert #xcb0ce00d60
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; railx-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rail-warp-gate (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spt-birth-func-capsulescreen function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mech-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern mech-spawn-thruster function) ;; (function mech-info vector vector float float none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mech ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mech (process-drawable)
|
|
((extra-trans vector :inline :offset-assert 208)
|
|
(condition int32 :offset-assert 224)
|
|
(shadow-backup basic :offset-assert 228)
|
|
(rider uint64 :offset-assert 232)
|
|
(shield-value float :offset-assert 240)
|
|
(nav-sphere-handle uint64 :offset-assert 248)
|
|
(probe-time uint64 :offset-assert 256) ;; time-frame
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x108
|
|
:flag-assert #x1900900108
|
|
(:methods
|
|
(mech-method-24 () none) ;; 24 ;; (mech-method-24 (_type_) none 24)
|
|
)
|
|
(:state-methods
|
|
wait-for-start ;; 20, old: (wait-for-start () _type_ :state 20)
|
|
idle ;; 21, old: (idle () _type_ :state 21)
|
|
pickup ;; 22, old: (pickup ((state mech)) _type_ :state 22)
|
|
wait-for-return ;; 23, old: (wait-for-return () _type_ :state 23)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mech-target (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
active ;; 21, old: (active () _type_ :state 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern mech-init function) ;; (function entity-actor matrix3 handle float none :behavior mech)
|
|
;; (define-extern mech-target-init function) ;; (function vector quaternion entity-actor none :behavior mech)
|
|
;; (define-extern mech-target-spawn function) ;; (function vector process quaternion entity-actor (pointer mech-target))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; billiards ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype billiard-ball (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(prev-pos vector :inline :offset-assert 16)
|
|
(size float :offset-assert 32)
|
|
(flags uint32 :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype billiard-ball-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype billiard-table (basic)
|
|
((billiards basic :offset-assert 4)
|
|
(accum-force vector :inline :offset-assert 16)
|
|
(drag float :offset-assert 32)
|
|
(bounds UNKNOWN 2 :offset-assert 48)
|
|
(min-xyz vector :inline :offset-assert 48)
|
|
(max-xyz vector :inline :offset-assert 64)
|
|
(bounce-wall-friction float :offset-assert 80)
|
|
(ball-friction float :offset-assert 84)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x58
|
|
:flag-assert #x1000000058
|
|
(:methods
|
|
(billiard-table-method-9 () none) ;; 9
|
|
(billiard-table-method-10 () none) ;; 10
|
|
(billiard-table-method-11 () none) ;; 11
|
|
(billiard-table-method-12 () none) ;; 12
|
|
(billiard-table-method-13 () none) ;; 13
|
|
(billiard-table-method-14 () none) ;; 14
|
|
(billiard-table-method-15 () none) ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mech-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *mech-exploder-params* joint-exploder-static-params) ;; joint-exploder-static-params
|
|
;; (define-extern check-turn-on-shield function)
|
|
;; (define-extern mech-can-throw? function)
|
|
;; (define-extern target-mech-punch-pick function) ;; (function symbol int :behavior target)
|
|
;; (define-extern target-mech-carry-update function) ;; (function none :behavior target)
|
|
;; (define-extern target-mech-carry-post function) ;; (function none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nstb-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *nstb-quicksand-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precurd-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-bat ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mh-bat (enemy)
|
|
((rotation-matrix matrix :inline :offset-assert 560)
|
|
(move-curve cubic-curve :inline :offset-assert 624)
|
|
(start-pos vector :inline :offset-assert 688)
|
|
(up-vector vector :inline :offset-assert 704)
|
|
(focus-bullseye-pos vector :inline :offset-assert 720)
|
|
(focus-xz-dir vector :inline :offset-assert 752)
|
|
(target-velocity vector :inline :offset-assert 768)
|
|
(target-speed float :offset-assert 784)
|
|
(y-offset float :offset-assert 788)
|
|
(max-time-step float :offset-assert 792)
|
|
(orbit-angle float :offset-assert 796)
|
|
(orbit-angular-speed float :offset-assert 800)
|
|
(orbit-distance float :offset-assert 804)
|
|
(bank-angle float :offset-assert 808)
|
|
(pitch-angle float :offset-assert 812)
|
|
(anim-speed float :offset-assert 816)
|
|
(last-off-screen-time uint64 :offset-assert 824)
|
|
(nav-mesh basic :offset-assert 832)
|
|
(flap-interp float :offset-assert 836)
|
|
(shadow-id int32 :offset-assert 840)
|
|
(move-dest vector :inline :offset-assert 368)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x34c
|
|
:flag-assert #xa202d0034c
|
|
(:methods
|
|
(mh-bat-method-158 () none) ;; 158
|
|
(mh-bat-method-159 () none) ;; 159
|
|
(mh-bat-method-160 () none) ;; 160
|
|
(mh-bat-method-161 () none) ;; 161
|
|
)
|
|
(:state-methods
|
|
dormant-aware ;; 29
|
|
stare ;; 37
|
|
attack-1 ;; 157
|
|
ambush ;; 47
|
|
retreat ;; 155
|
|
hostile ;; 38
|
|
attack-0 ;; 156
|
|
knocked-recover ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-mh-bat-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *mh-bat-enemy-info* enemy-info)
|
|
;; (define-extern mh-bat-fly-code function)
|
|
;; (define-extern mh-bat-fly-post function)
|
|
;; (define-extern mh-bat-chase-post function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nest-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; timer-path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype timer-chase-node (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(is-spawn? basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *timer-chase-path-0* array)
|
|
;; (define-extern *timer-chase-path-1* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; des-bush-time-chase ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype trail-effect (process-drawable)
|
|
((trail uint64 :offset-assert 200)
|
|
(goal-part basic :offset-assert 208)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd4
|
|
:flag-assert #x16006000d4
|
|
(:state-methods
|
|
idle ;; 20
|
|
dormant ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype timer-chase-trail (light-trail-tracker-projectile)
|
|
((time-offset uint64 :offset-assert 192)
|
|
(start-tracking? basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xcc
|
|
:flag-assert #x18005000cc
|
|
(:methods
|
|
(timer-chase-trail-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
tracking ;; 14
|
|
fadeout ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bb-goal (process-drawable)
|
|
((activate-radius float :offset-assert 200)
|
|
(sound-id uint32 :offset-assert 204)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd0
|
|
:flag-assert #x16005000d0
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bb-freeze (process-drawable)
|
|
((launch-pos vector :inline :offset-assert 208)
|
|
(activate-radius float :offset-assert 224)
|
|
(freeze-time float :offset-assert 228)
|
|
(freeze-pickup-radius float :offset-assert 232)
|
|
(bb-pickup-type uint8 :offset-assert 236)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xed
|
|
:flag-assert #x17007000ed
|
|
(:state-methods
|
|
dormant ;; 21
|
|
idle ;; 20
|
|
die ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype a-bb-freeze (bb-freeze)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xed
|
|
:flag-assert #x17007000ed
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype b-bb-freeze (bb-freeze)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xed
|
|
:flag-assert #x17007000ed
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype freeze-time-hud (hud-goal)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-timer-chase (task-manager)
|
|
((actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(freeze-time float :offset-assert 244)
|
|
(path-pos float :offset-assert 248)
|
|
(trail-effect uint64 :offset-assert 252)
|
|
(trans vector :inline :offset-assert 268)
|
|
(freeze-activation-radius float :offset-assert 284)
|
|
(goal-activation-radius float :offset-assert 288)
|
|
(total-time float :offset-assert 292)
|
|
(touched basic :offset-assert 296)
|
|
(freeze-time float :offset-assert 244)
|
|
(freeze-time-1 float :offset-assert 304)
|
|
(freeze-time-2 float :offset-assert 308)
|
|
(freeze-time-3 float :offset-assert 312)
|
|
(freeze-pickup-radius float :offset-assert 316)
|
|
(freeze-time-hud uint64 :offset-assert 324)
|
|
(sound-id uint32 :offset-assert 332)
|
|
(color-flash-time uint64 :offset-assert 340)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x160
|
|
:flag-assert #x2300e00160
|
|
(:methods
|
|
(task-manager-bbush-timer-chase-method-32 () none) ;; 32
|
|
(task-manager-bbush-timer-chase-method-33 () none) ;; 33
|
|
(task-manager-bbush-timer-chase-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
resolution ;; 17
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-timer-chase-2 (task-manager-bbush-timer-chase)
|
|
()
|
|
:method-count-assert 35
|
|
:size-assert #x160
|
|
:flag-assert #x2300e00160
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-timer-chase-3 (task-manager-bbush-timer-chase)
|
|
()
|
|
:method-count-assert 35
|
|
:size-assert #x160
|
|
:flag-assert #x2300e00160
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *tex-time-chase-level-list* array)
|
|
;; (define-extern find-time-chase-level-name function)
|
|
;; (define-extern *bb-alpha* object)
|
|
;; (define-extern spt-func-bb-fader function)
|
|
;; (define-extern *bb-timer-chase-trail* object)
|
|
;; (define-extern trail-effect-init-by-other function)
|
|
;; (define-extern bb-goal-init-by-other function)
|
|
;; (define-extern bb-pickup-type->string function)
|
|
;; (define-extern set-time-chase-particle-texture function)
|
|
;; (define-extern bb-freeze-init-by-other function)
|
|
;; (define-extern a-bb-freeze-init-by-other function)
|
|
;; (define-extern b-bb-freeze-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyslumc-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cty-elevator (elevator)
|
|
()
|
|
:method-count-assert 52
|
|
:size-assert #x1a0
|
|
:flag-assert #x34012001a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyslumc-flag (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ctyslumc-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern ctyslumc-flag-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; guard ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *guard-died-recently?* object)
|
|
;; (define-extern *crimson-guard-global-info* guard-global-info) ;; guard-global-info
|
|
;; (define-extern *crimson-guard-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern *guard-min-id-hack* object) ;; int
|
|
;; (define-extern do-spline function) ;; (function vector vector vector vector vector float vector)
|
|
;; (define-extern guard-type->city-target-type function)
|
|
;; (define-extern orient-towards-code function)
|
|
;; (define-extern go-active-if-necessary function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; combx-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; artifact-race ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype artifact-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(time uint32 :offset-assert 16)
|
|
(artifact-type uint8 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x15
|
|
:flag-assert #x900000015
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype was-artifact (process-drawable)
|
|
((pos vector :inline :offset-assert 208)
|
|
(angs vector :inline :offset-assert 224)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xf0
|
|
:flag-assert #x1a007000f0
|
|
(:methods
|
|
(was-artifact-method-23 () none) ;; 23
|
|
(was-artifact-method-24 () none) ;; 24
|
|
(was-artifact-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
sink ;; 21
|
|
die ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-artifact-race (task-manager)
|
|
((count int8 :offset-assert 240)
|
|
(max-count int8 :offset-assert 241)
|
|
(death-count uint8 :offset-assert 242)
|
|
(target-count int8 :offset-assert 243)
|
|
(target-speed float :offset-assert 244)
|
|
(slave uint64 :offset-assert 248)
|
|
(speech-time uint64 :offset-assert 256)
|
|
(final-time uint32 :offset-assert 264)
|
|
(suck-factor float :offset-assert 268)
|
|
(extra-suck-time float :offset-assert 272)
|
|
(hit-point-scale float :offset-assert 276)
|
|
(dust-begin float :offset-assert 280)
|
|
(dust-last-artifact float :offset-assert 284)
|
|
(dust-end float :offset-assert 288)
|
|
(ent basic :offset-assert 292)
|
|
(speech-callback basic :offset-assert 296)
|
|
(begin-pos vector :inline :offset-assert 304)
|
|
(end-pos vector :inline :offset-assert 320)
|
|
(door-plane vector :inline :offset-assert 336)
|
|
(objs UNKNOWN 32 :offset-assert 352)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x560
|
|
:flag-assert #x2304e00560
|
|
(:methods
|
|
(task-manager-desert-artifact-race-method-32 () none) ;; 32
|
|
(task-manager-desert-artifact-race-method-33 () none) ;; 33
|
|
(task-manager-desert-artifact-race-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
complete ;; 16
|
|
fail ;; 18
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern was-artifact-init-by-other function)
|
|
;; (define-extern was-artifact-spawn function)
|
|
;; (define-extern *artifact-race-speech-list* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-ai ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-factoryc ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *factoryc-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factoryc-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype generic-spot-shadow-effect (process-drawable)
|
|
((focal-length float :offset-assert 200)
|
|
(near-clip float :offset-assert 204)
|
|
(far-clip float :offset-assert 208)
|
|
(color uint32 :offset-assert 212)
|
|
(pre-flicker-pos vector :inline :offset-assert 224)
|
|
(jmod-outer joint-mod-add-local :inline :offset-assert 240)
|
|
(jmod-inner joint-mod-add-local :inline :offset-assert 304)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x170
|
|
:flag-assert #x1800f00170
|
|
(:methods
|
|
(generic-spot-shadow-effect-method-22 () none) ;; 22
|
|
(generic-spot-shadow-effect-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
inactive ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-zapper (process)
|
|
((on-duration uint64 :offset-assert 128)
|
|
(off-duration uint64 :offset-assert 136)
|
|
(phase-offset uint64 :offset-assert 144)
|
|
(beam-is-on basic :offset-assert 152)
|
|
(bzzt-sound uint32 :offset-assert 156)
|
|
(path basic :offset-assert 160)
|
|
(lightning basic :offset-assert 164)
|
|
(hilite uint64 :offset-assert 168)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #xb0
|
|
:flag-assert #xf003000b0
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-fire-torch (process-drawable)
|
|
((on-duration uint64 :offset-assert 200)
|
|
(off-duration uint64 :offset-assert 208)
|
|
(phase-offset uint64 :offset-assert 216)
|
|
(fire-is-on basic :offset-assert 224)
|
|
(sync sync-eased :inline :offset-assert 232)
|
|
(path-pos float :offset-assert 276)
|
|
(looping-sound uint32 :offset-assert 280)
|
|
(particle-hack matrix :inline :offset-assert 288)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x160
|
|
:flag-assert #x1500e00160
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robopod (process-focusable)
|
|
((my-baby UNKNOWN 3 :offset-assert 208)
|
|
(num-babies uint32 :offset-assert 232)
|
|
(subtask-countdown int32 :offset-assert 236)
|
|
(suppressed basic :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf4
|
|
:flag-assert #x20008000f4
|
|
(:state-methods
|
|
idle ;; 28
|
|
generate ;; 29
|
|
die ;; 30
|
|
already-dead ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-elec-gate (process)
|
|
((path-l basic :offset-assert 124)
|
|
(path-r basic :offset-assert 128)
|
|
(beams UNKNOWN 4 :offset-assert 132)
|
|
(beams-on UNKNOWN 4 :offset-assert 148)
|
|
(bzzt-sound uint32 :offset-assert 164)
|
|
(blocking-plane uint64 :offset-assert 172)
|
|
(actor-group uint32 :offset-assert 180)
|
|
(actor-group-count int32 :offset-assert 184)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xc0
|
|
:flag-assert #x10004000c0
|
|
(:state-methods
|
|
idle ;; 14
|
|
flickering ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern factoryc-activate function)
|
|
;; (define-extern factoryc-login function)
|
|
;; (define-extern factoryc-logout function)
|
|
;; (define-extern generic-spot-shadow-effect-init-by-other function)
|
|
;; (define-extern generic-spot-shadow-effect-handler function)
|
|
;; (define-extern *fac-robopod-pool-count* object)
|
|
;; (define-extern *fac-robopod-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern fac-robopod-add-hoverbot function)
|
|
;; (define-extern fac-robopod-invalidate-hoverbot function)
|
|
;; (define-extern fac-robopod-base-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factoryc-obs2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fac-break-floor (process-drawable)
|
|
((notify-actor basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-break-fence (process-focusable)
|
|
((notify-actor basic :offset-assert 208)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #xd4
|
|
:flag-assert #x1e006000d4
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-break-fence-a (fac-break-fence)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #xd8
|
|
:flag-assert #x1e006000d8
|
|
(:state-methods
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-break-fence-b (fac-break-fence)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #xd8
|
|
:flag-assert #x1e006000d8
|
|
(:state-methods
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-break-fence-c (fac-break-fence)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #xd8
|
|
:flag-assert #x1e006000d8
|
|
(:state-methods
|
|
idle ;; 28
|
|
die ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-switch (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
(lever-jmod joint-mod-rotate-local :inline :offset-assert 204)
|
|
(part-red basic :offset-assert 164)
|
|
(part-green basic :offset-assert 236)
|
|
(minimap connection-minimap :offset-assert 240)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xf8
|
|
:flag-assert #x17008000f8
|
|
(:methods
|
|
(fac-switch-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
done ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-move-plat-a (plat)
|
|
((dead-set-time float :offset-assert 324)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x148
|
|
:flag-assert #x2800d00148
|
|
(:methods
|
|
(fac-move-plat-a-method-39 () none) ;; 39
|
|
)
|
|
(:state-methods
|
|
plat-idle ;; 35
|
|
plat-path-active ;; 36
|
|
locking-down ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-move-plat-b (plat)
|
|
()
|
|
:method-count-assert 38
|
|
:size-assert #x144
|
|
:flag-assert #x2600d00144
|
|
(:state-methods
|
|
plat-idle ;; 35
|
|
plat-path-active ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-rotfan (process-drawable)
|
|
((motor-noise uint32 :offset-assert 200)
|
|
(effect-opacity float :offset-assert 204)
|
|
(no-collision-timer uint64 :offset-assert 208)
|
|
(attack-id int32 :offset-assert 216)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xdc
|
|
:flag-assert #x18006000dc
|
|
(:methods
|
|
(fac-rotfan-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
spindown ;; 21
|
|
out ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robot-ass-manager (process)
|
|
((name basic :offset-assert 0)
|
|
(mask process-mask :offset-assert 4)
|
|
(clock basic :offset-assert 8)
|
|
(parent uint32 :offset-assert 12)
|
|
(brother uint32 :offset-assert 16)
|
|
(child uint32 :offset-assert 20)
|
|
(ppointer uint32 :offset-assert 24)
|
|
(self basic :offset-assert 28)
|
|
(pool basic :offset-assert 32)
|
|
(status basic :offset-assert 36)
|
|
(pid int32 :offset-assert 40)
|
|
(main-thread basic :offset-assert 44)
|
|
(top-thread basic :offset-assert 48)
|
|
(entity basic :offset-assert 52)
|
|
(level basic :offset-assert 56)
|
|
(state basic :offset-assert 60)
|
|
(prev-state basic :offset-assert 64)
|
|
(next-state basic :offset-assert 68)
|
|
(state-stack basic :offset-assert 72)
|
|
(trans-hook basic :offset-assert 76)
|
|
(post-hook basic :offset-assert 80)
|
|
(event-hook basic :offset-assert 84)
|
|
(allocated-length int32 :offset-assert 88)
|
|
(heap-base uint32 :offset-assert 92)
|
|
(heap-top uint32 :offset-assert 96)
|
|
(heap-cur uint32 :offset-assert 100)
|
|
(stack-frame-top basic :offset-assert 104)
|
|
(heap kheap :inline :offset-assert 92)
|
|
(connection-list connectable :inline :offset-assert 108)
|
|
(stack UNKNOWN :dynamic :offset-assert 124)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-conveyor (conveyor)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #x100
|
|
:flag-assert #x1d00800100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-punch-wall (process-drawable)
|
|
((notify-actor basic :offset-assert 200)
|
|
(spool-sound-id uint32 :offset-assert 204)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd0
|
|
:flag-assert #x16005000d0
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fac-break-floor-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *fac-break-fence-a-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *fac-break-fence-b-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *fac-break-fence-c-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern fac-rotfan-part-trans function)
|
|
;; (define-extern perish-immediately state)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-indax-hang ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *indax-hang-walk-mods* surface)
|
|
;; (define-extern *indax-hang-dodge-mods* surface)
|
|
;; (define-extern *indax-hang-attack-mods* object)
|
|
;; (define-extern target-indax-hang-stance object)
|
|
;; (define-extern target-indax-hang-walk object)
|
|
;; (define-extern target-indax-hang-dodge object)
|
|
;; (define-extern target-indax-hang-attack object)
|
|
;; (define-extern target-indax-hang-turn-around object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-hijack-missile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cty-hijack-missile-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(track-obj uint64 :offset-assert 32)
|
|
(is-leader? basic :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype evasive-compare-params (structure)
|
|
((data UNKNOWN 3 :offset-assert 0)
|
|
(y-val float :offset-assert 0)
|
|
(angular-velocity float :offset-assert 4)
|
|
(speed float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype evasive-action-info (structure)
|
|
((start-values evasive-compare-params :inline :offset-assert 0)
|
|
(max-values evasive-compare-params :inline :offset-assert 12)
|
|
(difficulty float :offset-assert 24)
|
|
(evaded? basic :offset-assert 28)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x20
|
|
:flag-assert #xb00000020
|
|
(:methods
|
|
(evasive-action-info-method-9 () none) ;; 9
|
|
(evasive-action-info-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hijack-missile-bobber (structure)
|
|
((start-val float :offset-assert 0)
|
|
(current-val float :offset-assert 4)
|
|
(total-time uint64 :offset-assert 8)
|
|
(current-time uint64 :offset-assert 16)
|
|
(current-size-scalar float :offset-assert 24)
|
|
(dir float :offset-assert 28)
|
|
(num-iterations float :offset-assert 32)
|
|
(time-scalar float :offset-assert 36)
|
|
(start-time-scalar float :offset-assert 40)
|
|
(desired-time-scalar float :offset-assert 44)
|
|
(scale-min float :offset-assert 48)
|
|
(scale-max float :offset-assert 52)
|
|
(time-min float :offset-assert 56)
|
|
(time-max float :offset-assert 60)
|
|
(base-time float :offset-assert 64)
|
|
(current-speed float :offset-assert 68)
|
|
(output-scale float :offset-assert 72)
|
|
(output-val float :offset-assert 76)
|
|
(charge-time uint64 :offset-assert 80)
|
|
(wait-time uint64 :offset-assert 88)
|
|
(turning? basic :offset-assert 96)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x64
|
|
:flag-assert #xc00000064
|
|
(:methods
|
|
(hijack-missile-bobber-method-9 () none) ;; 9
|
|
(hijack-missile-bobber-method-10 () none) ;; 10
|
|
(hijack-missile-bobber-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-hijack-missile (process-focusable)
|
|
((tracked-player-positions basic :offset-assert 208)
|
|
(current-track-index uint32 :offset-assert 212)
|
|
(last-record-time uint64 :offset-assert 216)
|
|
(track-obj uint64 :offset-assert 224)
|
|
(current-speed float :offset-assert 232)
|
|
(target-speed float :offset-assert 236)
|
|
(lunge-speed float :offset-assert 240)
|
|
(temp-vec vector :inline :offset-assert 256)
|
|
(evasive-info evasive-action-info :inline :offset-assert 272)
|
|
(target-pos vector :inline :offset-assert 304)
|
|
(flee-vec vector :inline :offset-assert 320)
|
|
(is-leader? basic :offset-assert 336)
|
|
(offset-dist float :offset-assert 340)
|
|
(vel-factor float :offset-assert 344)
|
|
(original-quat quaternion :inline :offset-assert 352)
|
|
(rotate-deg float :offset-assert 368)
|
|
(basetrans vector :inline :offset-assert 384)
|
|
(lisa lissajous-interp :inline :offset-assert 400)
|
|
(next-lisa-time uint64 :offset-assert 488)
|
|
(lisa-pt vector :inline :offset-assert 496)
|
|
(circle-mag float :offset-assert 512)
|
|
(last-trans vector :inline :offset-assert 528)
|
|
(min-chase-speed float :offset-assert 544)
|
|
(min-targ-chase-speed float :offset-assert 548)
|
|
(max-chase-speed float :offset-assert 552)
|
|
(targ-scale-factor float :offset-assert 556)
|
|
(scale-factor float :offset-assert 560)
|
|
(missile-dist float :offset-assert 564)
|
|
(stage int8 :offset-assert 568)
|
|
(particle-trail basic :offset-assert 572)
|
|
(particle-trail-thrust basic :offset-assert 576)
|
|
(peel-off-sound uint32 :offset-assert 580)
|
|
(bobber hijack-missile-bobber :inline :offset-assert 584)
|
|
)
|
|
:method-count-assert 54
|
|
:size-assert #x2ac
|
|
:flag-assert #x36023002ac
|
|
(:methods
|
|
(cty-hijack-missile-method-29 () none) ;; 29
|
|
(cty-hijack-missile-method-32 () none) ;; 32
|
|
(cty-hijack-missile-method-33 () none) ;; 33
|
|
(cty-hijack-missile-method-34 () none) ;; 34
|
|
(cty-hijack-missile-method-43 () none) ;; 43
|
|
(cty-hijack-missile-method-44 () none) ;; 44
|
|
(cty-hijack-missile-method-45 () none) ;; 45
|
|
(cty-hijack-missile-method-46 () none) ;; 46
|
|
(cty-hijack-missile-method-47 () none) ;; 47
|
|
(cty-hijack-missile-method-48 () none) ;; 48
|
|
(cty-hijack-missile-method-49 () none) ;; 49
|
|
(cty-hijack-missile-method-50 () none) ;; 50
|
|
(cty-hijack-missile-method-51 () none) ;; 51
|
|
(cty-hijack-missile-method-52 () none) ;; 52
|
|
(cty-hijack-missile-method-53 () none) ;; 53
|
|
)
|
|
(:state-methods
|
|
lure ;; 36
|
|
idle ;; 28
|
|
initial-launch ;; 41
|
|
explode ;; 31
|
|
die ;; 39
|
|
explode-tiny ;; 40
|
|
lunge-prepare ;; 35
|
|
lure-die ;; 37
|
|
fake-chase ;; 42
|
|
chasing-2 ;; 38
|
|
chasing ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *missile-dist-near* object)
|
|
;; (define-extern *missile-dist-far* object)
|
|
;; (define-extern cty-hijack-missile-init-by-other function)
|
|
;; (define-extern compute-target-speed function)
|
|
;; (define-extern cty-hijack-missile-chase-event-handler function)
|
|
;; (define-extern *k0* object)
|
|
;; (define-extern *k1* object)
|
|
;; (define-extern *missile-dist-start* object)
|
|
;; (define-extern *accel-scalar* object)
|
|
;; (define-extern *use-lunging* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; spydroid ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype sensor-light-info (structure)
|
|
((joint int16 :offset-assert 0)
|
|
(part-index int16 :offset-assert 2)
|
|
(offset vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype spydroid (kg-squad-member)
|
|
((old-y-deg float :offset-assert 1124)
|
|
(diff-angle float :offset-assert 1128)
|
|
(desire-turn symbol :offset-assert 1132) ;; guessed by decompiler
|
|
(hit-target basic :offset-assert 1136)
|
|
(floor float :offset-assert 1140)
|
|
(explode-part sparticle-launch-control :offset-assert 1144) ;; guessed by decompiler
|
|
(alert-level uint8 :offset-assert 1148)
|
|
(next-check-player-time uint64 :offset-assert 1152)
|
|
(part-ids UNKNOWN 9 :offset-assert 1160)
|
|
(sensor-lights UNKNOWN 3 :offset-assert 1184)
|
|
(last-sensor-time uint64 :offset-assert 1280)
|
|
(exiting-wait? basic :offset-assert 1288)
|
|
)
|
|
:method-count-assert 238
|
|
:size-assert #x50c
|
|
:flag-assert #xee0490050c
|
|
(:methods
|
|
(spydroid-method-226 () none) ;; 226
|
|
(spydroid-method-231 () none) ;; 231
|
|
(spydroid-method-232 () none) ;; 232
|
|
(spydroid-method-233 () none) ;; 233
|
|
(spydroid-method-234 () none) ;; 234
|
|
(spydroid-method-235 () none) ;; 235
|
|
(spydroid-method-236 () none) ;; 236
|
|
(spydroid-method-237 () none) ;; 237
|
|
)
|
|
(:state-methods
|
|
search ;; 223
|
|
knocked ;; 31
|
|
scan ;; 225
|
|
die-falling ;; 41
|
|
wait-for-vulnerable ;; 229
|
|
attack ;; 222
|
|
hostile ;; 38
|
|
exit-transport ;; 230
|
|
flip ;; 228
|
|
spydroid-notice ;; 227
|
|
wait ;; 190
|
|
hunting ;; 224
|
|
active ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *spydroid-debris-params* debris-static-params)
|
|
;; (define-extern *spydroid-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern wait-for-vulnerable-close state)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flying-turret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ft-gun-info (structure)
|
|
((gun-position float :offset-assert 0)
|
|
(fire? basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flying-turret (kg-squad-member)
|
|
((thrust-dir vector :inline :offset-assert 1136)
|
|
(speed float :offset-assert 1152)
|
|
(speed-target float :offset-assert 1156)
|
|
(ground-height float :offset-assert 1160)
|
|
(last-heading-quat quaternion :inline :offset-assert 1168)
|
|
(last-roll-quat quaternion :inline :offset-assert 1184)
|
|
(thrust-mode uint8 :offset-assert 1200)
|
|
(pursuit-start-time uint64 :offset-assert 1208)
|
|
(chase-mode uint8 :offset-assert 1216)
|
|
(last-check-chase-pos-time uint64 :offset-assert 1224)
|
|
(circle-angle float :offset-assert 1232)
|
|
(last-fire-time uint64 :offset-assert 1240)
|
|
(num-shots-fired int8 :offset-assert 1248)
|
|
(ground-point vector :inline :offset-assert 1264)
|
|
(guns UNKNOWN 2 :offset-assert 1280)
|
|
(turret-aim-blend float :offset-assert 1312)
|
|
(hit-player? basic :offset-assert 1316)
|
|
(desired-height-offset float :offset-assert 1320)
|
|
(float-height float :offset-assert 1324)
|
|
(bob-velocity float :offset-assert 1328)
|
|
(bouncing? basic :offset-assert 1332)
|
|
(bounce-start-time uint64 :offset-assert 1336)
|
|
(changed-targets? basic :offset-assert 1344)
|
|
(thruster-intensity float :offset-assert 1348)
|
|
(up-bobbing? basic :offset-assert 1352)
|
|
(bob-scale-factor float :offset-assert 1356)
|
|
(bob-scale-target float :offset-assert 1360)
|
|
(bob-t float :offset-assert 1364)
|
|
(thruster-intensity-scalar float :offset-assert 1368)
|
|
(engine-sound uint32 :offset-assert 1372)
|
|
(tilt-sound uint32 :offset-assert 1376)
|
|
(roll-sound-amount float :offset-assert 1380)
|
|
)
|
|
:method-count-assert 231
|
|
:size-assert #x568
|
|
:flag-assert #xe704f00568
|
|
(:methods
|
|
(flying-turret-method-225 () none) ;; 225
|
|
(flying-turret-method-226 () none) ;; 226
|
|
(flying-turret-method-227 () none) ;; 227
|
|
(flying-turret-method-228 () none) ;; 228
|
|
(flying-turret-method-229 () none) ;; 229
|
|
(flying-turret-method-230 () none) ;; 230
|
|
)
|
|
(:state-methods
|
|
flying-turret-base-state ;; 222
|
|
hostile ;; 38
|
|
active ;; 34
|
|
fire ;; 223
|
|
knocked ;; 31
|
|
exit-transport ;; 224
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flying-turret-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *flying-turret-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern *flying-turret-debris-params* debris-static-params)
|
|
;; (define-extern flying-turret-gun-aim-func function)
|
|
;; (define-extern flying-turret-gun-recoil-jmod-func function)
|
|
;; (define-extern spawn-turret-projectile function)
|
|
;; (define-extern update-ft-gun function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hfrag-common ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hfrag-texture-anim ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern wang-texture-anim-init function)
|
|
;; (define-extern real-wang-texture-anim-func function)
|
|
;; (define-extern wang-texture-anim-func function)
|
|
;; (define-extern *hfrag-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-plant ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype eco-green-board-hint (process)
|
|
((state-time uint64 :offset-assert 128)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x88
|
|
:flag-assert #xf00100088
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-plant (process-focusable)
|
|
((attack-id uint32 :offset-assert 208)
|
|
(sound-id uint32 :offset-assert 212)
|
|
(sub-state uint32 :offset-assert 216)
|
|
(sub-state-time uint64 :offset-assert 224)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #xe8
|
|
:flag-assert #x25007000e8
|
|
(:methods
|
|
(mh-plant-method-32 () none) ;; 32
|
|
(mh-plant-method-33 () none) ;; 33
|
|
(mh-plant-method-34 () none) ;; 34
|
|
(mh-plant-method-35 () none) ;; 35
|
|
(mh-plant-method-36 () none) ;; 36
|
|
)
|
|
(:state-methods
|
|
pop-up ;; 28
|
|
idle ;; 29
|
|
repopulate ;; 30
|
|
die ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern eco-green-board-hint-init-by-other function)
|
|
;; (define-extern mh-plant-event-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype desert-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
(bsphere0 vector :inline :offset-assert 16)
|
|
(bsphere1 vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desertg-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
(bsphere vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype deswalk-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
(bsphere0 vector :inline :offset-assert 16)
|
|
(bsphere1 vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-desert function)
|
|
;; (define-extern init-mood-desertg function)
|
|
;; (define-extern update-mood-desertg function)
|
|
;; (define-extern update-mood-deswalk function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-color-desert-hanging-fire-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-desert-hanging-fire-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-hanging-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-hanging-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-desert-hanging-fire-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-desert-hanging-fire-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-desert-hanging-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-hanging-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-desert-hanging-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-hanging-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *part-desert-hanging-fire-flame-curve-settings* object)
|
|
;; (define-extern *range-color-desert-bowl-fire-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-desert-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-bowl-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-bowl-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-desert-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-desert-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-desert-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-desert-bowl-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-bowl-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *part-desert-bowl-fire-flame-curve-settings* object)
|
|
;; (define-extern *range-color-desert-small-bowl-fire-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-desert-small-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-small-bowl-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-small-bowl-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-desert-small-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-desert-small-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-desert-small-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-small-bowl-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-desert-small-bowl-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-small-bowl-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *part-desert-small-bowl-fire-flame-curve-settings* object)
|
|
;; (define-extern *scenecamera-fog-update?* object)
|
|
;; (define-extern scenecamera-fog-update function)
|
|
;; (define-extern *range-color-desert-palace-fire-beacon-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-desert-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-palace-fire-beacon-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-palace-fire-beacon-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-desert-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-desert-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-desert-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *curve-desert-palace-fire-beacon-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-palace-fire-beacon-flame-y* curve2d-fast)
|
|
;; (define-extern *part-desert-palace-fire-beacon-flame-curve-settings* object)
|
|
;; (define-extern birth-func-desert-beacon-set-accel function)
|
|
;; (define-extern *range-color-desert-totem-head-fire-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-desert-totem-head-fire-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-totem-head-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-totem-head-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-desert-totem-head-fire-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-desert-totem-head-fire-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-desert-totem-head-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-totem-head-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-desert-totem-head-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-totem-head-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *part-desert-totem-head-fire-flame-curve-settings* object)
|
|
;; (define-extern *range-color-firepit-fire-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-firepit-fire-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-firepit-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-firepit-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-firepit-fire-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-firepit-fire-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-firepit-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-firepit-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-firepit-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-firepit-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *part-firepit-fire-flame-curve-settings* object)
|
|
;; (define-extern *stronghold-range-color-flame* curve-color-fast)
|
|
;; (define-extern *stronghold-range-alpha-flame* curve2d-fast)
|
|
;; (define-extern *stronghold-range-scale-flame-x* curve2d-fast)
|
|
;; (define-extern *stronghold-range-scale-flame-y* curve2d-fast)
|
|
;; (define-extern *r-stronghold-curve-flame* curve2d-fast)
|
|
;; (define-extern *g-stronghold-curve-flame* curve2d-fast)
|
|
;; (define-extern *b-stronghold-curve-flame* curve2d-fast)
|
|
;; (define-extern *stronghold-curve-alpha-flame* curve2d-fast)
|
|
;; (define-extern *stronghold-curve-flame-x* curve2d-fast)
|
|
;; (define-extern *stronghold-curve-flame-y* curve2d-fast)
|
|
;; (define-extern *part-stronghold-torchfire-flame-curve-settings* object)
|
|
;; (define-extern *range-color-desert-bollard-fire-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-desert-bollard-fire-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-bollard-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-bollard-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-desert-bollard-fire-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-desert-bollard-fire-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-desert-bollard-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-bollard-fire-flame* curve2d-fast)
|
|
;; (define-extern *curve-desert-bollard-fire-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-bollard-fire-flame-y* curve2d-fast)
|
|
;; (define-extern *part-desert-bollard-fire-flame-curve-settings* object)
|
|
;; (define-extern *range-dessplash-color* curve-color-fast)
|
|
;; (define-extern *range-dessplash-alpha* curve2d-fast)
|
|
;; (define-extern *range-dessplash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-dessplash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-dessplash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-dessplash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-dessplash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-desert-water-rocks-splash-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-func-part-desert-shot-edges function)
|
|
;; (define-extern spt-func-spt-func-part-desert-barrier-puffs function)
|
|
;; (define-extern spt-func-spt-func-part-desert-barrier-sparks function)
|
|
;; (define-extern *nest-hunt-res-point* array)
|
|
;; (define-extern *nest-hunt-res-index* object)
|
|
;; (define-extern spt-birth-func-brightness-buggy-fly function)
|
|
;; (define-extern spt-birth-func-part-buggy-fly function)
|
|
;; (define-extern *range-oasis-hellcat-dust-color* curve-color-fast)
|
|
;; (define-extern *range-oasis-hellcat-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-oasis-hellcat-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-oasis-hellcat-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-oasis-hellcat-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-oasis-hellcat-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-oasis-hellcat-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-oasis-hellcat-dust-trail-curve-settings* object)
|
|
;; (define-extern spt-birth-func-brightness-t-foot-impact-dust function)
|
|
;; (define-extern *range-terraformer-fma-explo-color* curve-color-fast)
|
|
;; (define-extern *range-terraformer-fma-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-terraformer-fma-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-terraformer-fma-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-terraformer-fma-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-terraformer-fma-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-terraformer-fma-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-terraformer-fma-explosion-texture-curve-settings* object)
|
|
;; (define-extern spt-birth-func-brightness-buggy-skid function)
|
|
;; (define-extern spt-birth-func-part-buggy-skid function)
|
|
;; (define-extern spt-birth-func-brightness-daxter-impact-dust function)
|
|
;; (define-extern spt-birth-func-brightness-daxter-run-dust function)
|
|
;; (define-extern *range-color-desert-scenes-impact-dust* curve-color-fast)
|
|
;; (define-extern *range-alpha-desert-scenes-impact-dust* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-scenes-impact-dust-x* curve2d-fast)
|
|
;; (define-extern *range-scale-desert-scenes-impact-dust-y* curve2d-fast)
|
|
;; (define-extern *curve-alpha-desert-scenes-impact-dust* curve2d-fast)
|
|
;; (define-extern *curve-desert-scenes-impact-dust-x* curve2d-fast)
|
|
;; (define-extern *curve-desert-scenes-impact-dust-y* curve2d-fast)
|
|
;; (define-extern *part-desert-scenes-impact-dust-curve-settings* object)
|
|
;; (define-extern spt-birth-func-part-desert-scenes-bits function)
|
|
;; (define-extern *range-terexplo-color* curve-color-fast)
|
|
;; (define-extern *range-terexplo-alpha* curve2d-fast)
|
|
;; (define-extern *range-terexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-terexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-terexplo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-terexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-terexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-terraformer-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctywide-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype security-wall (process-drawable)
|
|
((pass int32 :offset-assert 200)
|
|
(incoming-attack-id uint32 :offset-assert 204)
|
|
(next-message-time uint64 :offset-assert 208) ;; int64
|
|
(message int32 :offset-assert 216)
|
|
(plane plane :inline :offset-assert 224)
|
|
(color vector :inline :offset-assert 240)
|
|
(target-pos vector :inline :offset-assert 256)
|
|
(flash float :offset-assert 272)
|
|
(touch-count int32 :offset-assert 276)
|
|
(breach symbol :offset-assert 280) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x11c
|
|
:flag-assert #x1900a0011c
|
|
(:methods
|
|
(security-wall-method-22 () none) ;; 22 ;; (security-wall-method-22 (_type_ path-control float) vector 22)
|
|
(security-wall-method-23 () none) ;; 23 ;; (security-wall-method-23 (_type_) none 23)
|
|
(security-wall-method-24 () none) ;; 24 ;; (security-wall-method-24 (_type_) none 24)
|
|
)
|
|
(:state-methods
|
|
idle-close ;; 21, old: (idle-close () _type_ :state 21)
|
|
idle-open ;; 20, old: (idle-open () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype security-wall-child (security-wall)
|
|
((hidden? basic :offset-assert 284)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x120
|
|
:flag-assert #x1a00a00120
|
|
(:state-methods
|
|
idle-close ;; 21
|
|
hide-wall ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype parking-spot (process-drawable)
|
|
((vehicle uint64 :offset-assert 200) ;; handle
|
|
(spawned symbol :offset-assert 208) ;; guessed by decompiler
|
|
(minimap connection-minimap :offset-assert 212)
|
|
(test-sphere sphere :inline :offset-assert 224)
|
|
(expire-time uint64 :offset-assert 240)
|
|
(last-update-time uint64 :offset-assert 248)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #x100
|
|
:flag-assert #x1b00800100
|
|
(:methods
|
|
(parking-spot-method-21 () none) ;; 21 ;; (parking-spot-method-21 (_type_) none 21)
|
|
(parking-spot-method-22 () none) ;; 22 ;; (parking-spot-method-22 (_type_) none 22)
|
|
(parking-spot-method-23 () none) ;; 23 ;; (parking-spot-method-23 (_type_ uint) none 23)
|
|
(parking-spot-method-24 () none) ;; 24 ;; (parking-spot-method-24 (_type_) none 24)
|
|
(parking-spot-method-25 () none) ;; 25
|
|
(parking-spot-method-26 () none) ;; 26
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype propa (process-focusable)
|
|
((sound-id sound-id :offset-assert 208) ;; guessed by decompiler
|
|
(sound-index uint32 :offset-assert 212)
|
|
(handle uint64 :offset-assert 216) ;; handle
|
|
(y-rot float :offset-assert 224)
|
|
(hit-points int32 :offset-assert 228)
|
|
(incoming-attack-id uint32 :offset-assert 232)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xec
|
|
:flag-assert #x21007000ec
|
|
(:methods
|
|
(propa-method-30 () none) ;; 30 ;; (propa-method-30 (_type_) none 30)
|
|
(propa-method-31 () none) ;; 31 ;; (propa-method-31 (_type_ vector) none 31)
|
|
(propa-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
broken ;; 29, old: (propa-method-29 (_type_) none 29)
|
|
idle ;; 28, old: (broken () _type_ :state 28)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype burning-bush (process-focusable)
|
|
((task game-task-control :offset-assert 208) ;; guessed by decompiler
|
|
(part-off sparticle-launch-control :offset-assert 212) ;; guessed by decompiler
|
|
(part-alert sparticle-launch-control :offset-assert 216) ;; guessed by decompiler
|
|
(angle float :offset-assert 220) ;; degrees
|
|
(time float :offset-assert 224)
|
|
(rotmin float :offset-assert 228)
|
|
(rotmax float :offset-assert 232)
|
|
(bb-perm entity-perm :offset-assert 236)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #xf0
|
|
:flag-assert #x23007000f0
|
|
(:methods
|
|
(burning-bush-method-32 () none) ;; 32 ;; (burning-bush-method-32 (_type_) object 32)
|
|
(burning-bush-method-33 () none) ;; 33
|
|
(burning-bush-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
collect-gems ;; 31, old: (burning-bush-method-31 (_type_) none 31)
|
|
idle ;; 28, old: (talking () _type_ :state 28)
|
|
talking ;; 29, old: (menu () _type_ :state 29)
|
|
menu ;; 30, old: (burning-bush-method-30 (_type_) none 30)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype city-burning-bush-get-on-info (structure)
|
|
((trans vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(camera-trans vector :inline :offset-assert 32)
|
|
(camera-rot UNKNOWN 9 :offset-assert 48)
|
|
(time float :offset-assert 84)
|
|
(fov float :offset-assert 88)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5c
|
|
:flag-assert #x90000005c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-ctywide-bbush-get-to (task-manager)
|
|
((skill uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xf8
|
|
:flag-assert #x21008000f8
|
|
(:methods
|
|
(task-manager-ctywide-bbush-get-to-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ctyn-lamp (process-focusable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xd0
|
|
:flag-assert #x20005000d0
|
|
(:methods
|
|
(ctyn-lamp-method-30 () none) ;; 30 ;; (ctyn-lamp-method-30 (_type_) none 30)
|
|
(ctyn-lamp-method-31 () none) ;; 31
|
|
)
|
|
(:state-methods
|
|
idle ;; 28, old: (die () _type_ :state 28)
|
|
die ;; 29, old: (ctyn-lamp-method-29 (_type_) none 29)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-lowrez-move (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(roty float :offset-assert 8)
|
|
(rotz float :offset-assert 12)
|
|
(rot-bob float :offset-assert 16)
|
|
(wobble float :offset-assert 20)
|
|
(bob float :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-lorez (process-drawable)
|
|
((move-info fac-lowrez-move :inline :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xe4
|
|
:flag-assert #x15007000e4
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flitter-spawner (process-drawable)
|
|
((root basic :offset-assert 124)
|
|
(actor-group uint32 :offset-assert 200)
|
|
(actor-group-count int32 :offset-assert 204)
|
|
(spawner basic :offset-assert 208)
|
|
(desired-spawn-count int32 :offset-assert 212)
|
|
(spawn-times basic :offset-assert 216)
|
|
(last-seen-times basic :offset-assert 220)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xe4
|
|
:flag-assert #x16007000e4
|
|
(:methods
|
|
(flitter-spawner-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flitter-point (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype board-score-hud (hud-goal)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-bbush-board (task-manager)
|
|
((score float :offset-assert 240)
|
|
(challenge-done basic :offset-assert 244)
|
|
(hud-score uint64 :offset-assert 248)
|
|
(hud-goal uint64 :offset-assert 256)
|
|
(game-score uint8 :offset-assert 264)
|
|
(new-high-score basic :offset-assert 268)
|
|
(goal-cup uint8 :offset-assert 272)
|
|
(last-cup uint8 :offset-assert 273)
|
|
(roll-back-task? basic :offset-assert 276)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x118
|
|
:flag-assert #x2300a00118
|
|
(:methods
|
|
(task-manager-bbush-board-method-32 () none) ;; 32
|
|
(task-manager-bbush-board-method-33 () none) ;; 33
|
|
(task-manager-bbush-board-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
resolution ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-tower-smoke-cty (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern security-wall-child-init-by-other function)
|
|
;; (define-extern spawn-security-wall function)
|
|
;; (define-extern parking-spot-spawn function)
|
|
;; (define-extern *propa-sounds* array) ;; (array string)
|
|
;; (define-extern *propa-sounds-class-3* array) ;; (array string)
|
|
;; (define-extern *propa-sounds-class-2* array) ;; (array string)
|
|
;; (define-extern *propa-sounds-class-1* array) ;; (array string)
|
|
;; (define-extern *propa-sounds-metalheads* array) ;; (array string)
|
|
;; (define-extern *propa-sounds-baron-construction* array) ;; (array string)
|
|
;; (define-extern propa-pu->knocked-type function) ;; (function penetrate knocked-type)
|
|
;; (define-extern *city-burning-bush-get-on-info* array)
|
|
;; (define-extern *ctyn-lamp-exploder-params* joint-exploder-static-params) ;; joint-exploder-static-params
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; squad-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vehicle-info (structure)
|
|
((handle-by-vehicle-type UNKNOWN 44 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x160
|
|
:flag-assert #x900000160
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-lookup-info (structure)
|
|
((turn-radius meters :offset-assert 0)
|
|
(throttle-turning float :offset-assert 4)
|
|
(throttle-straight float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-control-point (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(normal vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-attach-point (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(rot vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-wheel-info (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(flags uint64 :offset-assert 16)
|
|
(callback basic :offset-assert 24)
|
|
(inertia float :offset-assert 28)
|
|
(radius float :offset-assert 32)
|
|
(susp-arm-length float :offset-assert 36)
|
|
(steer-arm-length float :offset-assert 40)
|
|
(scale float :offset-assert 44)
|
|
(travel float :offset-assert 48)
|
|
(probe-y-offset float :offset-assert 52)
|
|
(width float :offset-assert 56)
|
|
(suspension-spring float :offset-assert 60)
|
|
(suspension-damping float :offset-assert 64)
|
|
(forward-grip float :offset-assert 68)
|
|
(side-grip float :offset-assert 72)
|
|
(max-brake-torque float :offset-assert 76)
|
|
(camber float :offset-assert 80)
|
|
(settle-pos float :offset-assert 84)
|
|
(probe-radius float :offset-assert 88)
|
|
(tread-texture basic :offset-assert 92)
|
|
(tread-tid uint32 :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x64
|
|
:flag-assert #x900000064
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-engine-info (structure)
|
|
((max-torque float :offset-assert 0)
|
|
(inertia float :offset-assert 4)
|
|
(drag float :offset-assert 8)
|
|
(idle-rpm float :offset-assert 12)
|
|
(clutch-min-rpm float :offset-assert 16)
|
|
(clutch-max-rpm float :offset-assert 20)
|
|
(min-rpm float :offset-assert 24)
|
|
(max-rpm float :offset-assert 28)
|
|
(peak-torque-rpm float :offset-assert 32)
|
|
(powerband-width-rpm float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-transmission-info (structure)
|
|
((inertia float :offset-assert 0)
|
|
(upshift-rpm float :offset-assert 4)
|
|
(downshift-rpm float :offset-assert 8)
|
|
(final-drive-ratio float :offset-assert 12)
|
|
(gear-ratio-array UNKNOWN 8 :offset-assert 16)
|
|
(gear-count int8 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x31
|
|
:flag-assert #x900000031
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-handling-info (structure)
|
|
((max-engine-thrust meters :offset-assert 0)
|
|
(inv-max-engine-thrust float :offset-assert 4)
|
|
(engine-response-rate float :offset-assert 8)
|
|
(engine-intake-factor float :offset-assert 12)
|
|
(brake-factor float :offset-assert 16)
|
|
(turbo-boost-factor float :offset-assert 20)
|
|
(turbo-boost-duration uint16 :offset-assert 24)
|
|
(max-xz-speed meters :offset-assert 28)
|
|
(player-turn-anim-bias float :offset-assert 32)
|
|
(player-turn-anim-min float :offset-assert 36)
|
|
(player-turn-anim-max float :offset-assert 40)
|
|
(pilot-x-accel-factor float :offset-assert 44)
|
|
(pilot-y-accel-factor float :offset-assert 48)
|
|
(pilot-z-accel-factor float :offset-assert 52)
|
|
(ground-probe-distance meters :offset-assert 56)
|
|
(ground-probe-offset meters :offset-assert 60)
|
|
(cos-ground-effect-angle float :offset-assert 64)
|
|
(spring-lift-factor float :offset-assert 68)
|
|
(air-steering-factor float :offset-assert 72)
|
|
(air-drag-factor float :offset-assert 76)
|
|
(steering-fin-angle float :offset-assert 80)
|
|
(steering-thruster-factor float :offset-assert 84)
|
|
(steering-thruster-max-gain float :offset-assert 88)
|
|
(steering-thruster-half-gain-speed meters :offset-assert 92)
|
|
(tire-steering-angle float :offset-assert 96)
|
|
(tire-steering-speed-factor float :offset-assert 100)
|
|
(tire-steering-speed-bias float :offset-assert 104)
|
|
(ackermann-factor float :offset-assert 108)
|
|
(tire-friction-factor float :offset-assert 112)
|
|
(tire-static-friction float :offset-assert 116)
|
|
(tire-static-friction-speed meters :offset-assert 120)
|
|
(tire-dynamic-friction float :offset-assert 124)
|
|
(tire-dynamic-friction-speed meters :offset-assert 128)
|
|
(tire-inv-max-friction-speed float :offset-assert 132)
|
|
(airfoil-factor float :offset-assert 136)
|
|
(drag-force-factor float :offset-assert 140)
|
|
(rolling-resistance float :offset-assert 144)
|
|
(speed-scrubbing-drag float :offset-assert 148)
|
|
(speed-limiting-drag float :offset-assert 152)
|
|
(pitch-control-factor float :offset-assert 156)
|
|
(roll-control-factor float :offset-assert 160)
|
|
(roll-angle float :offset-assert 164)
|
|
(jump-thrust-factor float :offset-assert 168)
|
|
(buoyancy-factor float :offset-assert 172)
|
|
(water-drag-factor float :offset-assert 176)
|
|
(player-weight float :offset-assert 180)
|
|
(player-shift-x meters :offset-assert 184)
|
|
(player-shift-z meters :offset-assert 188)
|
|
(air-roll-torque float :offset-assert 192)
|
|
(air-pitch-torque float :offset-assert 196)
|
|
(air-angular-damping float :offset-assert 200)
|
|
(hop-turn-torque float :offset-assert 204)
|
|
(ground-torque-scale float :offset-assert 208)
|
|
(ai-steering-factor float :offset-assert 212)
|
|
(ai-throttle-factor float :offset-assert 216)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xdc
|
|
:flag-assert #x9000000dc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-physics-model-info (structure)
|
|
((lift-thruster-count int8 :offset-assert 0)
|
|
(roll-thruster-count int8 :offset-assert 1)
|
|
(stabilizer-count int8 :offset-assert 2)
|
|
(inv-lift-thruster-count float :offset-assert 4)
|
|
(lift-thruster-array UNKNOWN 4 :offset-assert 16)
|
|
(roll-thruster-array UNKNOWN 2 :offset-assert 144)
|
|
(stabilizer-array UNKNOWN 6 :offset-assert 208)
|
|
(engine-thrust-local-pos vector :inline :offset-assert 400)
|
|
(brake-local-pos vector :inline :offset-assert 416)
|
|
(wheel-count int8 :offset-assert 432)
|
|
(drive-wheel-count int8 :offset-assert 433)
|
|
(front-wheel vehicle-wheel-info :inline :offset-assert 448)
|
|
(rear-wheel vehicle-wheel-info :inline :offset-assert 560)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x294
|
|
:flag-assert #x900000294
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-camera-info (structure)
|
|
((string-min-height meters :offset-assert 0)
|
|
(string-max-height meters :offset-assert 4)
|
|
(string-min-length meters :offset-assert 8)
|
|
(string-max-length meters :offset-assert 12)
|
|
(min-fov float :offset-assert 16)
|
|
(max-fov float :offset-assert 20)
|
|
(head-offset float :offset-assert 24)
|
|
(foot-offset float :offset-assert 28)
|
|
(normal-max-angle-offset float :offset-assert 32)
|
|
(air-max-angle-offset float :offset-assert 36)
|
|
(max-lookaround-speed float :offset-assert 40)
|
|
(look-pos-array UNKNOWN 4 :offset-assert 48)
|
|
(look-front vector :inline :offset-assert 48)
|
|
(look-left vector :inline :offset-assert 64)
|
|
(look-right vector :inline :offset-assert 80)
|
|
(look-rear vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-sound-loop-info (structure)
|
|
((sound uint128 :offset-assert 0)
|
|
(speed float :offset-assert 16)
|
|
(min-speed float :offset-assert 20)
|
|
(max-speed float :offset-assert 24)
|
|
(pitch-offset float :offset-assert 28)
|
|
(pitch-scale float :offset-assert 32)
|
|
(min-pitch float :offset-assert 36)
|
|
(max-pitch float :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-sound-info (structure)
|
|
((engine-pitch-scale float :offset-assert 0)
|
|
(engine-pitch-offset float :offset-assert 4)
|
|
(engine-pitch-mod-amp float :offset-assert 8)
|
|
(engine-sound-select int8 :offset-assert 12)
|
|
(thrust-sound uint8 16 :offset-assert 16) ;; field uses ~g print with a quadword load!
|
|
(scrape-sound uint8 16 :offset-assert 32) ;; field uses ~g print with a quadword load!
|
|
(glance-sound uint8 16 :offset-assert 48) ;; field uses ~g print with a quadword load!
|
|
(impact-sound uint8 16 :offset-assert 64) ;; field uses ~g print with a quadword load!
|
|
(impact2-sound uint8 16 :offset-assert 80) ;; field uses ~g print with a quadword load!
|
|
(explode-sound uint8 16 :offset-assert 96) ;; field uses ~g print with a quadword load!
|
|
(explode2-sound uint8 16 :offset-assert 112) ;; field uses ~g print with a quadword load!
|
|
(extra-sound uint8 16 :offset-assert 128) ;; field uses ~g print with a quadword load!
|
|
(water-sound uint8 16 :offset-assert 144) ;; field uses ~g print with a quadword load!
|
|
(jump-sound uint8 16 :offset-assert 160) ;; field uses ~g print with a quadword load!
|
|
(turbo-sound uint8 16 :offset-assert 176) ;; field uses ~g print with a quadword load!
|
|
(damage-sound uint8 16 :offset-assert 192) ;; field uses ~g print with a quadword load!
|
|
(bank-replace basic :offset-assert 208)
|
|
(idle-rpm float :offset-assert 212)
|
|
(idle-pitch-scale float :offset-assert 216)
|
|
(idle-crossover-rpm float :offset-assert 220)
|
|
(engine-rpm float :offset-assert 224)
|
|
(engine-crossover-rpm float :offset-assert 228)
|
|
(start-sound uint8 16 :offset-assert 240) ;; field uses ~g print with a quadword load!
|
|
(stop-sound uint8 16 :offset-assert 256) ;; field uses ~g print with a quadword load!
|
|
(idle-sound uint8 16 :offset-assert 272) ;; field uses ~g print with a quadword load!
|
|
(engine-sound uint8 16 :offset-assert 288) ;; field uses ~g print with a quadword load!
|
|
(engine-load-sound uint8 16 :offset-assert 304) ;; field uses ~g print with a quadword load!
|
|
(susp-creak-sound uint8 16 :offset-assert 320) ;; field uses ~g print with a quadword load!
|
|
(susp-bottom-out-sound uint8 16 :offset-assert 336) ;; field uses ~g print with a quadword load!
|
|
(susp-speed-threshold float :offset-assert 352)
|
|
(tire-roll-sounds UNKNOWN 4 :offset-assert 368)
|
|
(tire-slide-sounds UNKNOWN 2 :offset-assert 560)
|
|
(tire-roll-hum-sound vehicle-sound-loop-info :inline :offset-assert 368)
|
|
(tire-roll-dirt-sound vehicle-sound-loop-info :inline :offset-assert 416)
|
|
(tire-roll-sand-sound vehicle-sound-loop-info :inline :offset-assert 464)
|
|
(tire-roll-knobby-sound vehicle-sound-loop-info :inline :offset-assert 512)
|
|
(tire-slide-road-sound vehicle-sound-loop-info :inline :offset-assert 560)
|
|
(tire-slide-dirt-sound vehicle-sound-loop-info :inline :offset-assert 608)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x290
|
|
:flag-assert #x900000290
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-particle-info (structure)
|
|
((headlight-count int8 :offset-assert 0)
|
|
(taillight-count int8 :offset-assert 1)
|
|
(thruster-flame-width meters :offset-assert 4)
|
|
(thruster-flame-length meters :offset-assert 8)
|
|
(thruster-local-pos UNKNOWN 2 :offset-assert 16)
|
|
(exhaust-local-pos UNKNOWN 2 :offset-assert 48)
|
|
(exhaust-local-dir UNKNOWN 2 :offset-assert 80)
|
|
(smoke-local-pos UNKNOWN 2 :offset-assert 112)
|
|
(smoke-local-vel UNKNOWN 2 :offset-assert 144)
|
|
(headlight-local-pos UNKNOWN 3 :offset-assert 176)
|
|
(taillight-local-pos UNKNOWN 2 :offset-assert 224)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x100
|
|
:flag-assert #x900000100
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-section-info (structure)
|
|
((damage-seg-array uint64 3 :offset-assert 0) ;; guessed by decompiler
|
|
(damage-seg-count int8 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x19
|
|
:flag-assert #x900000019
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-damage-info (structure)
|
|
((inv-toughness-factor float :offset-assert 0)
|
|
(hit-points float :offset-assert 4)
|
|
(inv-hit-points float :offset-assert 8)
|
|
(hit-threshold float :offset-assert 12)
|
|
(hit-small float :offset-assert 16)
|
|
(hit-big float :offset-assert 20)
|
|
(hit-deadly float :offset-assert 24)
|
|
(impact-damage-factor float :offset-assert 28)
|
|
(section-count int8 :offset-assert 32)
|
|
(section-array UNKNOWN 4 :offset-assert 40)
|
|
(section-bike-front vehicle-section-info :inline :offset-assert 40)
|
|
(section-bike-rear vehicle-section-info :inline :offset-assert 72)
|
|
(section-car-front-left vehicle-section-info :inline :offset-assert 40)
|
|
(section-car-rear-left vehicle-section-info :inline :offset-assert 72)
|
|
(section-car-front-right vehicle-section-info :inline :offset-assert 104)
|
|
(section-car-rear-right vehicle-section-info :inline :offset-assert 136)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa8
|
|
:flag-assert #x9000000a8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-setup-info (structure)
|
|
((settle-height float :offset-assert 0)
|
|
(settle-rot-x float :offset-assert 4)
|
|
(shadow-bot-clip float :offset-assert 8)
|
|
(shadow-locus-dist float :offset-assert 12)
|
|
(look-select uint8 :offset-assert 16)
|
|
(color-option-count int8 :offset-assert 17)
|
|
(color-option-select int8 :offset-assert 18)
|
|
(gun-yaw-min float :offset-assert 24)
|
|
(gun-yaw-max float :offset-assert 28)
|
|
(gun-pitch-min float :offset-assert 32)
|
|
(gun-pitch-max float :offset-assert 36)
|
|
(gun-z-offset float :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-seat-info (structure)
|
|
((data uint8 16 :offset-assert 0) ;; guessed by decompiler
|
|
(position vector :inline :offset-assert 0)
|
|
(pos-x float :offset-assert 0)
|
|
(pos-y float :offset-assert 4)
|
|
(pos-z float :offset-assert 8)
|
|
(angle int16 :offset-assert 12)
|
|
(flags uint8 :offset-assert 14)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-grab-rail-info (structure)
|
|
((local-pos vector 2 :offset-assert 0) ;; guessed by decompiler
|
|
(normal vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-rider-info (structure)
|
|
((seat-count int8 :offset-assert 0)
|
|
(rider-stance uint8 :offset-assert 1)
|
|
(grab-rail-count int8 :offset-assert 2)
|
|
(attach-point-count int8 :offset-assert 3)
|
|
(grab-rail-array uint32 :offset-assert 4)
|
|
(seat-array UNKNOWN 4 :offset-assert 16)
|
|
(rider-hand-offset UNKNOWN 2 :offset-assert 80)
|
|
(attach-point-array uint32 :offset-assert 112)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x74
|
|
:flag-assert #x900000074
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-explosion-info (joint-exploder-static-params)
|
|
((skel skeleton-group :offset-assert 40) ;; guessed by decompiler
|
|
(skel-name string :offset-assert 44) ;; guessed by decompiler
|
|
(anim int32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-particle-common-info (structure)
|
|
((headlight-glow-template sprite-glow-data :offset-assert 28)
|
|
(taillight-glow-template sprite-glow-data :offset-assert 32)
|
|
(thruster-glow-template sprite-glow-data :offset-assert 36)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x28
|
|
:flag-assert #xa00000028
|
|
(:methods
|
|
(vehicle-particle-common-info-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rigid-body-vehicle-constants (rigid-body-object-constants)
|
|
((flags uint32 :offset-assert 208)
|
|
(object-type uint8 :offset-assert 212)
|
|
(guard-type uint8 :offset-assert 213)
|
|
(vehicle-type uint8 :offset-assert 214)
|
|
(engine vehicle-engine-info :inline :offset-assert 216)
|
|
(transmission vehicle-transmission-info :inline :offset-assert 256)
|
|
(handling vehicle-handling-info :inline :offset-assert 308)
|
|
(target-speed-offset meters :offset-assert 528)
|
|
(turning-accel meters :offset-assert 532)
|
|
(camera vehicle-camera-info :inline :offset-assert 544)
|
|
(sound vehicle-sound-info :inline :offset-assert 656)
|
|
(particles vehicle-particle-info :inline :offset-assert 1312)
|
|
(damage vehicle-damage-info :inline :offset-assert 1568)
|
|
(physics-model vehicle-physics-model-info :inline :offset-assert 1744)
|
|
(setup vehicle-setup-info :inline :offset-assert 2404)
|
|
(rider vehicle-rider-info :inline :offset-assert 2448)
|
|
(explosion vehicle-explosion-info :offset-assert 2564) ;; guessed by decompiler
|
|
(explosion-part int32 :offset-assert 2568)
|
|
(debris basic :offset-assert 2572)
|
|
(name-text uint32 :offset-assert 2576)
|
|
(particle-common vehicle-particle-common-info :offset-assert 2580)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xa18
|
|
:flag-assert #xa00000a18
|
|
(:methods
|
|
(rigid-body-vehicle-constants-method-9 () none) ;; 9 ;; (rigid-body-vehicle-constants-method-9 (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-section (structure)
|
|
((damage float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle (rigid-body-object)
|
|
((flags vehicle-flag :offset-assert 212) ;; rigid-body-object-flag
|
|
(squad basic :offset-assert 300)
|
|
(control-hook basic :offset-assert 304)
|
|
(controls vehicle-controls :inline :offset-assert 308)
|
|
(prev-controls vehicle-controls :inline :offset-assert 332)
|
|
(engine-power-factor float :offset-assert 356)
|
|
(force-scale float :offset-assert 360)
|
|
(target-distance2 meters :offset-assert 364)
|
|
(water-flags uint32 :offset-assert 368)
|
|
(target-acceleration vector :inline :offset-assert 380)
|
|
(impact-pos vector :inline :offset-assert 396)
|
|
(impact-local-pos vector :inline :offset-assert 412)
|
|
(lin-acceleration vector :inline :offset-assert 428)
|
|
(hit-points float :offset-assert 444)
|
|
(damage-factor float :offset-assert 448)
|
|
(crash-level int8 :offset-assert 452)
|
|
(force-level int8 :offset-assert 453)
|
|
(traffic-hash-id int8 :offset-assert 454)
|
|
(traffic-priority-id int8 :offset-assert 455)
|
|
(power-fluctuation-factor float :offset-assert 456)
|
|
(power-level float :offset-assert 460)
|
|
(overlap-player-counter uint8 :offset-assert 464)
|
|
(physics-counter uint8 :offset-assert 465)
|
|
(cam-view int8 :offset-assert 466)
|
|
(brake-factor float :offset-assert 468)
|
|
(cam-speed-interp float :offset-assert 472)
|
|
(camera-dist2 float :offset-assert 476)
|
|
(player-dist2 float :offset-assert 480)
|
|
(bound-radius float :offset-assert 484)
|
|
(rider-array handle 4 :offset-assert 492) ;; guessed by decompiler
|
|
(impact-proc uint64 :offset-assert 524)
|
|
(impact-pat uint32 :offset-assert 532)
|
|
(impact-time uint32 :offset-assert 536)
|
|
(prev-impact-time uint32 :offset-assert 540)
|
|
(sent-attack-time time-frame :offset-assert 544) ;; guessed by decompiler
|
|
(air-time time-frame :offset-assert 548) ;; guessed by decompiler
|
|
(water-time uint32 :offset-assert 552)
|
|
(offscreen-time uint32 :offset-assert 556)
|
|
(crash-time time-frame :offset-assert 560) ;; guessed by decompiler
|
|
(turbo-boost-time time-frame :offset-assert 564) ;; guessed by decompiler
|
|
(player-dismount-time uint32 :offset-assert 568)
|
|
(crash-duration uint16 :offset-assert 572)
|
|
(turbo-boost-duration uint16 :offset-assert 574)
|
|
(turbo-boost-factor float :offset-assert 576)
|
|
(crash-impulse float :offset-assert 580)
|
|
(water-height float :offset-assert 584)
|
|
(lights-factor float :offset-assert 588)
|
|
(outgoing-attack-id uint32 :offset-assert 592)
|
|
(fog-fade float :offset-assert 596)
|
|
(scrape-sound-id sound-id :offset-assert 600) ;; guessed by decompiler
|
|
(damage-zap-sound-id sound-id :offset-assert 604) ;; guessed by decompiler
|
|
(scrape-sound-envelope float :offset-assert 608)
|
|
(exhaust-part-accum basic 2 :offset-assert 612) ;; guessed by decompiler
|
|
(smoke-part-accum basic 2 :offset-assert 620) ;; guessed by decompiler
|
|
(section-array vehicle-section 4 :offset-assert 628) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 152
|
|
:size-assert #x2b8
|
|
:flag-assert #x98024002b8
|
|
;; field vehicle-flag is likely a value type.
|
|
(:methods
|
|
(vehicle-method-56 () none) ;; 56 ;; (vehicle-state-56 () _type_ :state 56)
|
|
(vehicle-method-57 () none) ;; 57 ;; (player-control () _type_ :state 57)
|
|
(vehicle-method-58 () none) ;; 58 ;; (crash () _type_ :state 58)
|
|
(vehicle-method-59 () none) ;; 59 ;; (explode () _type_ :state 59)
|
|
(vehicle-method-60 () none) ;; 60 ;; (die () _type_ :state 60)
|
|
(vehicle-method-61 () none) ;; 61 ;; (measure-control-parameters () _type_ :state 61)
|
|
(vehicle-method-62 () none) ;; 62 ;; (vehicle-method-62 (_type_ float) none 62)
|
|
(vehicle-method-63 () none) ;; 63 ;; (vehicle-method-63 (_type_ float) none 63)
|
|
(vehicle-method-64 () none) ;; 64 ;; (vehicle-method-64 () none 64)
|
|
(vehicle-method-65 () none) ;; 65 ;; (start-jump (_type_) none 65)
|
|
(vehicle-method-66 () none) ;; 66 ;; (vehicle-method-66 (_type_) none 66)
|
|
(vehicle-method-67 () none) ;; 67 ;; (get-seat-count (_type_) int 67)
|
|
(vehicle-method-68 () none) ;; 68 ;; (compute-seat-position (_type_ vector int) none 68)
|
|
(vehicle-method-69 () none) ;; 69 ;; (get-rider-in-seat (_type_ int) process 69)
|
|
(vehicle-method-70 () none) ;; 70 ;; (vehicle-method-70 (_type_) process 70)
|
|
(vehicle-method-71 () none) ;; 71 ;; (put-rider-in-seat (_type_ int process-focusable) none 71)
|
|
(vehicle-method-72 () none) ;; 72 ;; (vehicle-method-72 (_type_) uint 72)
|
|
(vehicle-method-73 () none) ;; 73 ;; (get-best-seat-for-vehicle (_type_ vector int int) int 73)
|
|
(vehicle-method-74 () none) ;; 74 ;; (remove-rider (_type_ process) none 74)
|
|
(vehicle-method-75 () none) ;; 75 ;; (vehicle-method-75 (_type_) float 75)
|
|
(vehicle-method-76 () none) ;; 76 ;; (vehicle-method-76 (_type_ int uint) none 76)
|
|
(vehicle-method-77 () none) ;; 77 ;; (vehicle-method-77 (_type_) none 77)
|
|
(vehicle-method-78 () none) ;; 78 ;; (vehicle-method-78 (_type_ int) none 78)
|
|
(vehicle-method-79 () none) ;; 79 ;; (vehicle-method-79 (_type_) none 79)
|
|
(vehicle-method-80 () none) ;; 80 ;; (vehicle-method-80 (_type_) none 80)
|
|
(vehicle-method-81 () none) ;; 81 ;; (vehicle-method-81 (_type_) none 81)
|
|
(vehicle-method-82 () none) ;; 82 ;; (vehicle-method-82 (_type_) none 82)
|
|
(vehicle-method-83 () none) ;; 83 ;; (vehicle-method-83 (_type_) none 83)
|
|
(vehicle-method-84 () none) ;; 84 ;; (draw-thruster (_type_ vector vector float float) none 84)
|
|
(vehicle-method-85 () none) ;; 85 ;; (draw-thrusters (_type_) none 85)
|
|
(vehicle-method-86 () none) ;; 86 ;; (update-joint-mods (_type_) none 86)
|
|
(vehicle-method-87 () none) ;; 87 ;; (vehicle-method-87 (_type_) none 87)
|
|
(vehicle-method-88 () none) ;; 88 ;; (vehicle-method-88 (_type_) none 88)
|
|
(vehicle-method-89 () none) ;; 89 ;; (vehicle-method-89 (_type_) none 89)
|
|
(vehicle-method-90 () none) ;; 90 ;; (vehicle-method-90 (_type_) none 90)
|
|
(vehicle-method-91 () none) ;; 91 ;; (vehicle-method-91 (_type_) none 91)
|
|
(vehicle-method-92 () none) ;; 92 ;; (vehicle-method-92 (_type_) none 92)
|
|
(vehicle-method-93 () none) ;; 93 ;; (vehicle-method-93 (_type_) none 93)
|
|
(vehicle-method-94 () none) ;; 94 ;; (vehicle-method-94 (_type_) none 94)
|
|
(vehicle-method-95 () none) ;; 95 ;; (vehicle-method-95 (_type_ vector) none 95)
|
|
(vehicle-method-96 () none) ;; 96 ;; (vehicle-method-96 (_type_) none 96)
|
|
(vehicle-method-97 () none) ;; 97 ;; (vehicle-method-97 (_type_) none 97)
|
|
(vehicle-method-98 () none) ;; 98 ;; (vehicle-method-98 (_type_ float) none 98)
|
|
(vehicle-method-99 () none) ;; 99 ;; (vehicle-method-99 (_type_ float) none 99)
|
|
(vehicle-method-100 () none) ;; 100 ;; (vehicle-method-100 (_type_ float vehicle-physics-work) none 100)
|
|
(vehicle-method-101 () none) ;; 101 ;; (vehicle-method-101 (_type_) none 101)
|
|
(vehicle-method-102 () none) ;; 102 ;; (shadow-enable (_type_) none 102)
|
|
(vehicle-method-103 () none) ;; 103 ;; (shadow-disable (_type_) none 103)
|
|
(vehicle-method-104 () none) ;; 104 ;; (vehicle-method-104 (_type_) none 104)
|
|
(vehicle-method-105 () none) ;; 105 ;; (vehicle-method-105 (_type_) symbol 105)
|
|
(vehicle-method-106 () none) ;; 106 ;; (vehicle-method-106 (_type_) none 106)
|
|
(vehicle-method-107 () none) ;; 107 ;; (vehicle-method-107 (_type_) none 107)
|
|
(vehicle-method-108 () none) ;; 108 ;; (vehicle-method-108 (_type_) none 108)
|
|
(vehicle-method-109 () none) ;; 109 ;; (vehicle-method-109 (_type_) none 109)
|
|
(vehicle-method-110 () none) ;; 110 ;; (vehicle-method-110 (_type_) none 110)
|
|
(vehicle-method-111 () none) ;; 111 ;; (vehicle-method-111 (_type_ object target) none 111)
|
|
(vehicle-method-112 () none) ;; 112 ;; (decrease-traffic-alert-level (_type_ int) int 112)
|
|
(vehicle-method-113 () none) ;; 113 ;; (vehicle-method-113 (_type_) none 113)
|
|
(vehicle-method-114 () none) ;; 114 ;; (vehicle-method-114 (_type_) none 114)
|
|
(vehicle-method-115 () none) ;; 115 ;; (vehicle-method-115 (_type_ vector) none 115)
|
|
(vehicle-method-116 () none) ;; 116 ;; (vehicle-method-116 (_type_ (pointer vehicle-controls)) none 116)
|
|
(vehicle-method-117 () none) ;; 117 ;; (vehicle-method-117 (_type_ vector int int) none 117)
|
|
(vehicle-method-118 () none) ;; 118 ;; (vehicle-method-118 (_type_ int) none 118)
|
|
(vehicle-method-119 () none) ;; 119 ;; (vehicle-method-119 (_type_) none 119)
|
|
(vehicle-method-120 () none) ;; 120 ;; (vehicle-method-120 (_type_) none 120)
|
|
(vehicle-method-121 () none) ;; 121 ;; (vehicle-method-121 (_type_) none 121)
|
|
(vehicle-method-122 () none) ;; 122 ;; (vehicle-method-122 (_type_) none 122)
|
|
(vehicle-method-123 () none) ;; 123 ;; (vehicle-method-123 (_type_) none 123)
|
|
(vehicle-method-124 () none) ;; 124 ;; (vehicle-method-124 (_type_) none 124)
|
|
(vehicle-method-125 () none) ;; 125 ;; (vehicle-method-125 (_type_ float) none 125)
|
|
(vehicle-method-126 () none) ;; 126 ;; (vehicle-method-126 (_type_ float) none 126)
|
|
(vehicle-method-127 () none) ;; 127 ;; (vehicle-method-127 (_type_) none 127)
|
|
(vehicle-method-128 () none) ;; 128 ;; (vehicle-method-128 (_type_) none 128)
|
|
(vehicle-method-129 () none) ;; 129 ;; (vehicle-method-129 (_type_) none 129)
|
|
(vehicle-method-130 () none) ;; 130 ;; (vehicle-method-130 (_type_ traffic-object-spawn-params) none 130)
|
|
(vehicle-method-131 () none) ;; 131 ;; (vehicle-method-131 (_type_) none 131)
|
|
(vehicle-method-132 () none) ;; 132 ;; (vehicle-method-132 (_type_) none 132)
|
|
(vehicle-method-133 () none) ;; 133 ;; (check-player-get-on (_type_) none 133)
|
|
(vehicle-method-134 () none) ;; 134 ;; (vehicle-method-134 (_type_ process) none 134)
|
|
(vehicle-method-135 () none) ;; 135 ;; (vehicle-method-135 (_type_ traffic-object-spawn-params) none 135)
|
|
(vehicle-method-136 () none) ;; 136 ;; (vehicle-method-136 (_type_ traffic-object-spawn-params) none 136)
|
|
(vehicle-method-137 () none) ;; 137 ;; (vehicle-method-137 (_type_ traffic-object-spawn-params) none 137)
|
|
(vehicle-method-138 () none) ;; 138 ;; (vehicle-method-138 (_type_) none 138)
|
|
(vehicle-method-139 () none) ;; 139 ;; (vehicle-method-139 (_type_) none 139)
|
|
(vehicle-method-140 () none) ;; 140 ;; (vehicle-method-140 (_type_) none 140)
|
|
(vehicle-method-141 () none) ;; 141 ;; (vehicle-method-141 (_type_) none 141)
|
|
(vehicle-method-142 () none) ;; 142 ;; (vehicle-method-142 (_type_) none 142)
|
|
(vehicle-method-143 () none) ;; 143 ;; (vehicle-method-143 (_type_) none 143)
|
|
(vehicle-method-144 () none) ;; 144
|
|
(vehicle-method-145 () none) ;; 145
|
|
(vehicle-method-146 () none) ;; 146
|
|
(vehicle-method-147 () none) ;; 147
|
|
(vehicle-method-148 () none) ;; 148
|
|
(vehicle-method-149 () none) ;; 149
|
|
(vehicle-method-150 () none) ;; 150
|
|
(vehicle-method-151 () none) ;; 151
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-probe-work (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(local-normal vector :inline :offset-assert 16)
|
|
(world-pos vector :inline :offset-assert 32)
|
|
(world-normal vector :inline :offset-assert 48)
|
|
(probe-pos vector :inline :offset-assert 64)
|
|
(ground-pos vector :inline :offset-assert 80)
|
|
(ground-normal vector :inline :offset-assert 96)
|
|
(velocity vector :inline :offset-assert 112)
|
|
(tire-force vector :inline :offset-assert 128)
|
|
(wheel-axis vector :inline :offset-assert 144)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa0
|
|
:flag-assert #x9000000a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-physics-work (structure)
|
|
((mat matrix :inline :offset-assert 0)
|
|
(force vector :inline :offset-assert 64)
|
|
(velocity vector :inline :offset-assert 80)
|
|
(world-pos vector :inline :offset-assert 96)
|
|
(world-normal vector :inline :offset-assert 112)
|
|
(local-pos vector :inline :offset-assert 128)
|
|
(steering-axis vector :inline :offset-assert 144)
|
|
(lift-dir vector :inline :offset-assert 160)
|
|
(normal vector :inline :offset-assert 176)
|
|
(tmp vector :inline :offset-assert 192)
|
|
(p-body vector :inline :offset-assert 208)
|
|
(axis vector :inline :offset-assert 224)
|
|
(dir vector :inline :offset-assert 240)
|
|
(ground-normal vector :inline :offset-assert 256)
|
|
(impulse float :offset-assert 272)
|
|
(vel-dot-norm float :offset-assert 276)
|
|
(friction-coef float :offset-assert 280)
|
|
(speed-factor float :offset-assert 284)
|
|
(probe-work-array vehicle-probe-work 4 :offset-assert 288) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3a0
|
|
:flag-assert #x9000003a0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-draw-thruster-params (structure)
|
|
((quat quaternion :inline :offset-assert 0)
|
|
(trans vector :inline :offset-assert 16)
|
|
(thrust float :offset-assert 32)
|
|
(width float :offset-assert 36)
|
|
(length float :offset-assert 40)
|
|
(fog-fade float :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
;; (deftype debug-vehicle-work (basic)
|
|
;; ()
|
|
;; :flag-assert #x900000070
|
|
;; )
|
|
|
|
;; (define-extern meters-per-sec->mph function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *debug-vehicle-work* debug-vehicle-work) ;; debug-vehicle-work
|
|
;; (define-extern *vehicle-shadow-control* shadow-control) ;; shadow-control
|
|
;; (define-extern *vehicle-shadow-control-disabled* shadow-control) ;; shadow-control
|
|
;; (define-extern vehicle-event-handler function) ;; (function process int symbol event-message-block object :behavior vehicle)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-squad-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *default-mh-squad-member-settings* object)
|
|
;; (define-extern *war-mh-squad-member-settings* object)
|
|
;; (define-extern set-mh-primary-target function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; templed-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tpl-break-bridge-panel-info (structure)
|
|
((start-time uint64 :offset-assert 0)
|
|
(grace uint64 :offset-assert 8)
|
|
(fall-rate float :offset-assert 16)
|
|
(fall-rate-realtime float :offset-assert 20)
|
|
(time-to-terminal-velocity uint64 :offset-assert 24)
|
|
(tumble-axis vector :inline :offset-assert 32)
|
|
(tumble-rate-norm float :offset-assert 48)
|
|
(tumble-rate-slow float :offset-assert 52)
|
|
(detonate-altitude float :offset-assert 56)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x3c
|
|
:flag-assert #x90000003c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-break-bridge (process-drawable)
|
|
((panel-jmods UNKNOWN 21 :offset-assert 208)
|
|
(had-particle-spawned UNKNOWN 21 :offset-assert 1552)
|
|
(panel-quashed UNKNOWN 21 :offset-assert 1636)
|
|
(spool-sound-id uint32 :offset-assert 1720)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x6bc
|
|
:flag-assert #x1a064006bc
|
|
(:methods
|
|
(tpl-break-bridge-method-23 () none) ;; 23
|
|
(tpl-break-bridge-method-24 () none) ;; 24
|
|
(tpl-break-bridge-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
collapsing ;; 21
|
|
done ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-temple-tests-stupid-bridge (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *tpl-bbridge-array* array)
|
|
;; (define-extern *tpl-bridge-debris-params-arr* array)
|
|
;; (define-extern spt-birth-func-brightness-part-temple-bridge-break-dust function)
|
|
;; (define-extern tpl-bbridge-panel function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-physics ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcano-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-func-part-volcano-embers function)
|
|
;; (define-extern spt-func-birth-on-pop function)
|
|
;; (define-extern *lava-particle-list* array)
|
|
;; (define-extern birth-func-texture-group-lava function)
|
|
;; (define-extern spt-func-part-lava-ball-spout-puff function)
|
|
;; (define-extern spt-birth-func-brightness-part-volcano-leaf-fall function)
|
|
;; (define-extern spt-birth-func-part-volcano-leaf-fall function)
|
|
;; (define-extern spt-volcano-check-ground-lie-flat function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vehicle-manager (process)
|
|
((name basic :offset-assert 0)
|
|
(mask process-mask :offset-assert 4)
|
|
(clock basic :offset-assert 8)
|
|
(parent uint32 :offset-assert 12)
|
|
(brother uint32 :offset-assert 16)
|
|
(child uint32 :offset-assert 20)
|
|
(ppointer uint32 :offset-assert 24)
|
|
(self basic :offset-assert 28)
|
|
(pool basic :offset-assert 32)
|
|
(status basic :offset-assert 36)
|
|
(pid int32 :offset-assert 40)
|
|
(main-thread basic :offset-assert 44)
|
|
(top-thread basic :offset-assert 48)
|
|
(entity basic :offset-assert 52)
|
|
(level basic :offset-assert 56)
|
|
(state basic :offset-assert 60)
|
|
(prev-state basic :offset-assert 64)
|
|
(next-state basic :offset-assert 68)
|
|
(state-stack basic :offset-assert 72)
|
|
(trans-hook basic :offset-assert 76)
|
|
(post-hook basic :offset-assert 80)
|
|
(event-hook basic :offset-assert 84)
|
|
(allocated-length int32 :offset-assert 88)
|
|
(heap-base uint32 :offset-assert 92)
|
|
(heap-top uint32 :offset-assert 96)
|
|
(heap-cur uint32 :offset-assert 100)
|
|
(stack-frame-top basic :offset-assert 104)
|
|
(heap kheap :inline :offset-assert 92)
|
|
(connection-list connectable :inline :offset-assert 108)
|
|
(stack UNKNOWN :dynamic :offset-assert 124)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x80
|
|
:flag-assert #x1200000080
|
|
(:methods
|
|
(vehicle-manager-method-16 () none) ;; 16
|
|
(vehicle-manager-method-17 () none) ;; 17
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *vehicle-rigid-body-queue* object)
|
|
;; (define-extern *vehicle-info* object)
|
|
;; (define-extern vehicle-entity-hack function)
|
|
;; (define-extern vehicle-manager-event-handler function)
|
|
;; (define-extern vehicle-manager-init-by-other function)
|
|
;; (define-extern vehicle-manager-start function)
|
|
;; (define-extern vehicle-manager-kill function)
|
|
;; (define-extern vehicle-init-by-other function) ;; (function traffic-object-spawn-params none :behavior vehicle)
|
|
;; (define-extern vehicle-spawn-hack function)
|
|
;; (define-extern vehicle-spawn function) ;; (function process type traffic-object-spawn-params process-drawable)
|
|
;; (define-extern type-from-vehicle-type function) ;; (function vehicle-type type)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-hud ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-vehicle-health (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
;; (define-extern hud-vehicle-health-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-pilot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *pilot-mods* surface) ;; surface
|
|
;; (define-extern target-pilot-handler function) ;; (function process int symbol event-message-block object :behavior target)
|
|
;; (define-extern target-pilot-pidax-enter function) ;; (function object :behavior target)
|
|
;; (define-extern target-pilot-pidax-exit function) ;; (function object :behavior target)
|
|
;; (define-extern target-pilot-exit function) ;; (function object :behavior target)
|
|
;; (define-extern target-pilot-init function) ;; (function handle symbol object :behavior target)
|
|
;; (define-extern pilot-on-ground? function) ;; (function symbol :behavior target)
|
|
;; (define-extern target-pilot-post function) ;; (function none :behavior target)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vehicle-rider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vehicle-rider (process-focusable)
|
|
((squad basic :offset-assert 208)
|
|
(flags uint8 :offset-assert 212)
|
|
(riding-anim int32 :offset-assert 216)
|
|
(anim-t float :offset-assert 220)
|
|
(anim-speed float :offset-assert 224)
|
|
(seat-index int8 :offset-assert 228)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #xe5
|
|
:flag-assert #x25007000e5
|
|
(:methods
|
|
(vehicle-rider-method-32 () none) ;; 32 ;; (vehicle-rider-method-32 (_type_ traffic-object-spawn-params) none 32)
|
|
(vehicle-rider-method-33 () none) ;; 33 ;; (vehicle-rider-method-33 (_type_) none 33)
|
|
(vehicle-rider-method-34 () none) ;; 34 ;; (vehicle-rider-method-34 (_type_) none 34)
|
|
(vehicle-rider-method-35 () none) ;; 35 ;; (vehicle-rider-method-35 (_type_) none 35)
|
|
(vehicle-rider-method-36 () none) ;; 36
|
|
)
|
|
(:state-methods
|
|
active ;; 29, old: (taunt () _type_ :state 29)
|
|
taunt ;; 30, old: (got-passed () _type_ :state 30)
|
|
got-passed ;; 31, old: (initialize-collision (_type_) none 31)
|
|
inactive ;; 28, old: (active () _type_ :state 28)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype citizen-norm-rider (vehicle-rider)
|
|
()
|
|
:method-count-assert 37
|
|
:size-assert #xe5
|
|
:flag-assert #x25007000e5
|
|
)
|
|
|#
|
|
|
|
;; (define-extern vehicle-rider-event-handler function) ;; (function process int symbol event-message-block object :behavior vehicle-rider)
|
|
;; (define-extern vehicle-rider-init-by-other function) ;; (function traffic-object-spawn-params none :behavior vehicle-rider)
|
|
;; (define-extern vehicle-rider-spawn function) ;; (function vehicle type traffic-object-spawn-params process)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hvehicle ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; glider-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype glider-thermal-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(r float :offset-assert 12)
|
|
(hheight float :offset-assert 16)
|
|
(windspeed float :offset-assert 20)
|
|
(curpos float :offset-assert 24)
|
|
(thermal-time uint64 :offset-assert 32)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x28
|
|
:flag-assert #xa00000028
|
|
(:methods
|
|
(glider-thermal-info-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype glider-ring-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(forw vector :inline :offset-assert 16)
|
|
(boost float :offset-assert 32)
|
|
(dist float :offset-assert 36)
|
|
(xdist float :offset-assert 40)
|
|
(ydist float :offset-assert 44)
|
|
(toff uint64 :offset-assert 48)
|
|
(speedmod float :offset-assert 56)
|
|
(shootable basic :offset-assert 60)
|
|
(lastring basic :offset-assert 64)
|
|
(checkpoint uint8 :offset-assert 68)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x45
|
|
:flag-assert #xa00000045
|
|
(:methods
|
|
(glider-ring-info-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-glider (hvehicle)
|
|
((minalt float :offset-assert 944)
|
|
(curalt float :offset-assert 948)
|
|
(maxalt float :offset-assert 952)
|
|
(rollerr float :offset-assert 956)
|
|
(pitcherr float :offset-assert 960)
|
|
(alterr float :offset-assert 964)
|
|
(rolling basic :offset-assert 968)
|
|
(speed float :offset-assert 972)
|
|
(poierr float :offset-assert 976)
|
|
(poipos float :offset-assert 980)
|
|
(poivel float :offset-assert 984)
|
|
(deathspin basic :offset-assert 988)
|
|
(in-thermal basic :offset-assert 992)
|
|
(in-thermal-time uint64 :offset-assert 1000)
|
|
(min-thermal-time uint64 :offset-assert 1008)
|
|
(thermal-start-time uint64 :offset-assert 1016)
|
|
(thermal-strength float :offset-assert 1024)
|
|
(deathrot vector :inline :offset-assert 1040)
|
|
(last-ring-pos vector :inline :offset-assert 1056)
|
|
(progression-plane vector :inline :offset-assert 1072)
|
|
(birth uint64 :offset-assert 1088)
|
|
(stop-time uint64 :offset-assert 1096)
|
|
(pitch-down-time uint64 :offset-assert 1104)
|
|
(pitch-side-time uint64 :offset-assert 1112)
|
|
(ambient-wind-sound-time uint64 :offset-assert 1120)
|
|
(thermal-sound-time uint64 :offset-assert 1128)
|
|
(updraft-vel float :offset-assert 1136)
|
|
(updraft-acc float :offset-assert 1140)
|
|
(updraft-err float :offset-assert 1144)
|
|
(rel-up-vel float :offset-assert 1148)
|
|
(flap-pos float :offset-assert 1152)
|
|
(amb-sound uint32 :offset-assert 1156)
|
|
(amb-sound-playing basic :offset-assert 1160)
|
|
(full-speed-boost? basic :offset-assert 1164)
|
|
(lost-lift? basic :offset-assert 1168)
|
|
(lost-lift-time uint64 :offset-assert 1176)
|
|
(right-rudder joint-mod-rotate-local :inline :offset-assert 1184)
|
|
(left-rudder joint-mod-rotate-local :inline :offset-assert 1216)
|
|
(right-alerone joint-mod-rotate-local :inline :offset-assert 1248)
|
|
(left-alerone joint-mod-rotate-local :inline :offset-assert 1280)
|
|
(flap UNKNOWN 6 :offset-assert 1312)
|
|
)
|
|
:method-count-assert 163
|
|
:size-assert #x6a0
|
|
:flag-assert #xa3062006a0
|
|
(:methods
|
|
(h-glider-method-162 () none) ;; 162
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; glider-ring ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype light-trail-tracker-glider-ring (light-trail-tracker)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xac
|
|
:flag-assert #x15003000ac
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype glider-prim (simple-prim)
|
|
((far? basic :offset-assert 204)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xd0
|
|
:flag-assert #x1a005000d0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype glider-ring (process-drawable)
|
|
((touch-time uint64 :offset-assert 200)
|
|
(ring-prim uint64 :offset-assert 208)
|
|
(minimap connection-minimap :offset-assert 216)
|
|
(player-got basic :offset-assert 220)
|
|
(persistent basic :offset-assert 224)
|
|
(id int8 :offset-assert 228)
|
|
(boost float :offset-assert 232)
|
|
(plane vector :inline :offset-assert 240)
|
|
(save-pos vector :inline :offset-assert 256)
|
|
(up vector :inline :offset-assert 272)
|
|
(right vector :inline :offset-assert 288)
|
|
(part-track uint64 :offset-assert 304)
|
|
(mat matrix :inline :offset-assert 320)
|
|
(xdist float :offset-assert 384)
|
|
(ydist float :offset-assert 388)
|
|
(toff uint64 :offset-assert 392)
|
|
(speedmod float :offset-assert 400)
|
|
(shootable basic :offset-assert 404)
|
|
(lastring basic :offset-assert 408)
|
|
(shot basic :offset-assert 412)
|
|
(checkpoint uint8 :offset-assert 416)
|
|
(distant-part basic :offset-assert 420)
|
|
(blinky-part basic :offset-assert 424)
|
|
(blinky-gone? basic :offset-assert 428)
|
|
(do-trails? basic :offset-assert 432)
|
|
(trails UNKNOWN 5 :offset-assert 440)
|
|
(trail-joint UNKNOWN 5 :offset-assert 480)
|
|
(center-joint uint8 :offset-assert 485)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x1e6
|
|
:flag-assert #x1a017001e6
|
|
(:methods
|
|
(glider-ring-method-22 () none) ;; 22
|
|
(glider-ring-method-23 () none) ;; 23
|
|
(glider-ring-method-24 () none) ;; 24
|
|
(glider-ring-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype glider-thermal (process-drawable)
|
|
((id int8 :offset-assert 200)
|
|
(part-track uint64 :offset-assert 208)
|
|
(mat matrix :inline :offset-assert 224)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x120
|
|
:flag-assert #x1600a00120
|
|
(:methods
|
|
(glider-thermal-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *curve-glider-ring-linear-up-red* object)
|
|
;; (define-extern *trail-color-curve-glider-ring* curve-color-fast)
|
|
;; (define-extern *curve-glider-ring-linear-trail* curve2d-fast)
|
|
;; (define-extern *glider-ring-trail* object)
|
|
;; (define-extern sparticle-track-joint-glider function)
|
|
;; (define-extern glider-part-single-birth function)
|
|
;; (define-extern glider-ring-standard-event-handler function)
|
|
;; (define-extern *near-thermal-dist-squared* object)
|
|
;; (define-extern glider-ring-near-thermal-dist-squared function)
|
|
;; (define-extern glider-ring-init-by-other function)
|
|
;; (define-extern glider-ring-spawn function)
|
|
;; (define-extern glider-thermal-init-by-other function)
|
|
;; (define-extern glider-thermal-spawn function)
|
|
;; (define-extern glider-launch-mist-particle function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; glider-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-desert-glide (task-manager)
|
|
((desert-glide-entity basic :offset-assert 236)
|
|
(check-timer uint64 :offset-assert 244)
|
|
(start-time uint64 :offset-assert 164)
|
|
(thermal-start-time uint64 :offset-assert 260)
|
|
(actor-group uint32 :offset-assert 268)
|
|
(actor-group-count int32 :offset-assert 272)
|
|
(cur-group int8 :offset-assert 276)
|
|
(sound-id uint32 :offset-assert 280)
|
|
(count int32 :offset-assert 284)
|
|
(max-count int32 :offset-assert 288)
|
|
(pre-populated-clouds? basic :offset-assert 292)
|
|
(creating-thermal? basic :offset-assert 296)
|
|
(hud-altitude uint64 :offset-assert 300)
|
|
(hud-active? basic :offset-assert 308)
|
|
(editing? basic :offset-assert 312)
|
|
(did-want-load? basic :offset-assert 316)
|
|
(reset-too-low? basic :offset-assert 320)
|
|
(last-active-thermal int16 :offset-assert 324)
|
|
(whistle-sound uint32 :offset-assert 328)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x150
|
|
:flag-assert #x2800d00150
|
|
(:methods
|
|
(task-manager-desert-glide-method-32 () none) ;; 32
|
|
(task-manager-desert-glide-method-33 () none) ;; 33
|
|
(task-manager-desert-glide-method-34 () none) ;; 34
|
|
(task-manager-desert-glide-method-35 () none) ;; 35
|
|
(task-manager-desert-glide-method-36 () none) ;; 36
|
|
(task-manager-desert-glide-method-37 () none) ;; 37
|
|
(task-manager-desert-glide-method-38 () none) ;; 38
|
|
(task-manager-desert-glide-method-39 () none) ;; 39
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-glider (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *cloud-cube* object)
|
|
;; (define-extern pre-populate-clouds function)
|
|
;; (define-extern *ring-spawn-id* object)
|
|
;; (define-extern *desert-glide-num-rings* object)
|
|
;; (define-extern *desert-glide-rings-tmp* object)
|
|
;; (define-extern *desert-glide-thermal-effects* object)
|
|
;; (define-extern *desert-glide-rings* array)
|
|
;; (define-extern *glider-cache-index* object)
|
|
;; (define-extern *desert-glide-thermals* array)
|
|
;; (define-extern *desert-glide-finish-sphere* object)
|
|
;; (define-extern glider-too-low? function)
|
|
;; (define-extern *thermal-spawn-id* object)
|
|
;; (define-extern *desert-glide-num-thermals* object)
|
|
;; (define-extern *desert-glide-thermals-tmp* object)
|
|
;; (define-extern glider-thermal-updraft-velocity function)
|
|
;; (define-extern desert-glide-task-done function)
|
|
;; (define-extern inside-cloudbox? function)
|
|
;; (define-extern inside-cloudbox-xz? function)
|
|
;; (define-extern move-pos-inside-cloudbox! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; glider-hud ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; elec-gate ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype elec-gate-params (structure)
|
|
((bolt-spec lightning-spec :offset-assert 0) ;; guessed by decompiler
|
|
(ring-spec lightning-spec :offset-assert 4) ;; guessed by decompiler
|
|
(ring-radius-min float :offset-assert 8)
|
|
(ring-radius-max float :offset-assert 12)
|
|
(speed-mult float :offset-assert 16)
|
|
(min-dist float :offset-assert 20)
|
|
(max-dist float :offset-assert 24)
|
|
(plane-expand-xz float :offset-assert 28)
|
|
(plane-expand-y float :offset-assert 32)
|
|
(plane-shift-z float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype elec-gate-bolt (structure)
|
|
((ring lightning-control 2 :offset-assert 0) ;; guessed by decompiler
|
|
(bolt lightning-control :offset-assert 8) ;; guessed by decompiler
|
|
(ring-radius float :offset-assert 12)
|
|
(pos float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype elec-wall (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(dir vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype elec-gate (process-drawable)
|
|
((params elec-gate-params :offset-assert 200)
|
|
(path-l path-control :offset-assert 152) ;; guessed by decompiler
|
|
(path-r path-control :offset-assert 204) ;; guessed by decompiler
|
|
(l-bolt elec-gate-bolt 5 :offset-assert 208) ;; guessed by decompiler
|
|
(part-on sparticle-launch-control :offset-assert 168) ;; guessed by decompiler
|
|
(part-off sparticle-launch-control :offset-assert 368) ;; guessed by decompiler
|
|
(part-spawner-left part-spawner :offset-assert 372) ;; guessed by decompiler
|
|
(part-spawner-right part-spawner :offset-assert 376) ;; guessed by decompiler
|
|
(on-start pair :offset-assert 380) ;; guessed by decompiler
|
|
(on-stop pair :offset-assert 384) ;; guessed by decompiler
|
|
(on-shutdown basic :offset-assert 388)
|
|
(on-trigger basic :offset-assert 392)
|
|
(dividing-wall elec-wall :inline :offset-assert 400)
|
|
(plane elec-wall 2 :offset-assert 432) ;; guessed by decompiler
|
|
(wall-y float :offset-assert 496)
|
|
(wall-xz float :offset-assert 500)
|
|
(lightning-quality float :offset-assert 504)
|
|
(quality-enabled? symbol :offset-assert 508) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #x200
|
|
:flag-assert #x1f01800200
|
|
;; field on-start uses ~A with a signed load. field on-stop uses ~A with a signed load. field on-shutdown uses ~A with a signed load. field on-trigger uses ~A with a signed load.
|
|
(:methods
|
|
(elec-gate-method-24 () none) ;; 24 ;; (elec-gate-method-24 (_type_) none 24)
|
|
(elec-gate-method-25 () none) ;; 25 ;; (set-palette! (_type_) none 25)
|
|
(elec-gate-method-26 () none) ;; 26 ;; (set-state! (_type_) none 26)
|
|
(elec-gate-method-27 () none) ;; 27 ;; (spawn-particles (_type_ sparticle-launch-control) none 27)
|
|
(elec-gate-method-28 () none) ;; 28 ;; (set-elec-scale-if-close! (_type_ float) none 28)
|
|
(elec-gate-method-29 () none) ;; 29 ;; (set-elec-scale! (_type_ float) none 29)
|
|
(elec-gate-method-30 () none) ;; 30
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
active ;; 21, old: (active () _type_ :state 21)
|
|
shutdown-camera ;; 22, old: (shutdown () _type_ :state 22)
|
|
shutdown ;; 23, old: (get-params (_type_) elec-gate-params 23)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sewer-elec-gate (elec-gate)
|
|
((gate-index int32 :offset-assert 512)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #x204
|
|
:flag-assert #x1f01900204
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *default-elec-gate-params* object) ;; elec-gate-params
|
|
;; (define-extern elec-gate-post function) ;; (function none :behavior elec-gate)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; intro-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hiphog-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-catapult ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype catapult-shot-sphere (process-drawable)
|
|
((current-alpha float :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xd8
|
|
:flag-assert #x15006000d8
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype catapult-shot-sphere-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype v-catapult-shot (metalhead-grenade-shot)
|
|
((trail-part basic :offset-assert 532)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x218
|
|
:flag-assert #x2901a00218
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype v-catapult (wcar-base)
|
|
((jmod-axles UNKNOWN 4 :offset-assert 2752)
|
|
(jmod-gun-x joint-mod-rotate-local :inline :offset-assert 2880)
|
|
(jmod-gun-y joint-mod-rotate-local :inline :offset-assert 2912)
|
|
(turret-control turret-control :inline :offset-assert 2944)
|
|
(sub-state-time uint32 :offset-assert 3040)
|
|
(sub-state int8 :offset-assert 3044)
|
|
(launch-projectile? basic :offset-assert 3048)
|
|
(targ-pos vector :inline :offset-assert 3056)
|
|
(notify-handle uint64 :offset-assert 3072)
|
|
(spawn-part? basic :offset-assert 3080)
|
|
(charge-time uint64 :offset-assert 3088)
|
|
(exploding? basic :offset-assert 3096)
|
|
)
|
|
:method-count-assert 205
|
|
:size-assert #xc1c
|
|
:flag-assert #xcd0ba00c1c
|
|
(:methods
|
|
(v-catapult-method-203 () none) ;; 203
|
|
(v-catapult-method-204 () none) ;; 204
|
|
)
|
|
(:state-methods
|
|
explode ;; 60
|
|
hostile ;; 152
|
|
die ;; 61
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *v-catapult-turret-control-info* object)
|
|
;; (define-extern *v-catapult-turret-guard-settings* object)
|
|
;; (define-extern *v-catapult-debris-longspike-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-bar-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lpanel-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rpanel-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lbumperspikes-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rbumperspikes-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lfspike-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rfspike-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-ltopspike-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rtopspike-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lsidespikea-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lsidespikeb-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lsidespikec-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lsidespiked-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lsidespikee-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rsidespikea-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rsidespikeb-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rsidespikec-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rsidespiked-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rsidespikee-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lfpanela-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rfpanela-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lfpanelb-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rfpanelb-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lfpanelc-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rfpanelc-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lfpaneld-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rfpaneld-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lmpanela-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rmpanela-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lmpanelb-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rmpanelb-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lmpanelc-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rmpanelc-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lmpaneld-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rmpaneld-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lrpanela-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rrpanela-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lrpanelb-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rrpanelb-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lrpanelc-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rrpanelc-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-lrpaneld-params* debris-static-params)
|
|
;; (define-extern *v-catapult-debris-rrpaneld-params* debris-static-params)
|
|
;; (define-extern *range-ftexplo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-ftexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-v-catapult-shot-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-ftexplo-color* curve-color-fast)
|
|
;; (define-extern *range-ftexplo-alpha* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-v-catapult-shot-explosion-texture-curve-settings* object)
|
|
;; (define-extern catapult-shot-sphere-init-by-other function)
|
|
;; (define-extern *v-catapult-shot-impact-blur* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-jump ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wascity-airlock-debris (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:methods
|
|
(wascity-airlock-debris-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype beam-generator (process-drawable)
|
|
((arrow uint64 :offset-assert 200)
|
|
(pos vector :inline :offset-assert 208)
|
|
(angs vector :inline :offset-assert 224)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xf0
|
|
:flag-assert #x18007000f0
|
|
(:methods
|
|
(beam-generator-method-22 () none) ;; 22
|
|
(beam-generator-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-wasdoors-health (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-desert-catapult-count (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desjump-point (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desjump-vehicle (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(path-type uint8 :offset-assert 8)
|
|
(path-pos uint8 :offset-assert 9)
|
|
(ready? basic :offset-assert 12)
|
|
(kamikaze? basic :offset-assert 16)
|
|
(wait-timer uint64 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-jump-manager (task-manager)
|
|
((nav-mesh basic :offset-assert 240)
|
|
(vehicle UNKNOWN 2 :offset-assert 248)
|
|
(vehicle-count uint8 :offset-assert 312)
|
|
(v-free-list basic :offset-assert 316)
|
|
(total-veh-spawned uint8 :offset-assert 320)
|
|
(check-timer uint64 :offset-assert 328)
|
|
(hud-wasdoors-health uint64 :offset-assert 216)
|
|
(generator uint64 :offset-assert 336)
|
|
(interceptor UNKNOWN 4 :offset-assert 344)
|
|
(interceptor-count uint8 :offset-assert 472)
|
|
(i-free-list basic :offset-assert 476)
|
|
(interceptor-timer uint64 :offset-assert 480)
|
|
(plane vector :inline :offset-assert 496)
|
|
(last-catapult-pos vector :inline :offset-assert 512)
|
|
(player-can-win? basic :offset-assert 528)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x214
|
|
:flag-assert #x2301a00214
|
|
(:methods
|
|
(desert-jump-manager-method-32 () none) ;; 32
|
|
(desert-jump-manager-method-33 () none) ;; 33
|
|
(desert-jump-manager-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *wascity-airlock-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern beam-generator-init-by-other function)
|
|
;; (define-extern *desjump-wasdoors-pos* object)
|
|
;; (define-extern *desjump-vehicle-path* array)
|
|
;; (define-extern part-tracker-check-parent function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desertg-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype desert-elec-gate (elec-gate)
|
|
()
|
|
:method-count-assert 31
|
|
:size-assert #x200
|
|
:flag-assert #x1f01800200
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-eggwall (process-drawable)
|
|
((task-node uint16 :offset-assert 200)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xca
|
|
:flag-assert #x17005000ca
|
|
(:methods
|
|
(desert-eggwall-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-cactus-obstacle (process-focusable)
|
|
((explode-time uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #xd8
|
|
:flag-assert #x1d006000d8
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *desert-elec-gate-params* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mhcity-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bubbles-path (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
die ;; 21
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; terraformer-drone ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype terraformer-drone (nav-enemy)
|
|
((trail-part basic :offset-assert 620)
|
|
(spinner-jm basic :offset-assert 624)
|
|
(spinner-angle float :offset-assert 628)
|
|
(minimap connection-minimap :offset-assert 632)
|
|
(zigzag-counter int8 :offset-assert 636)
|
|
(zigzag-timer uint64 :offset-assert 640)
|
|
(zigzag-target vector :inline :offset-assert 656)
|
|
(floor float :offset-assert 672)
|
|
(engine-sound uint32 :offset-assert 676)
|
|
(engine-sound-playing basic :offset-assert 680)
|
|
)
|
|
:method-count-assert 192
|
|
:size-assert #x2ac
|
|
:flag-assert #xc0023002ac
|
|
(:state-methods
|
|
explode ;; 191
|
|
jump ;; 44
|
|
stare ;; 37
|
|
notice ;; 35
|
|
attack ;; 190
|
|
hostile ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype terraformer-drone-small (terraformer-drone)
|
|
()
|
|
:method-count-assert 192
|
|
:size-assert #x2ac
|
|
:flag-assert #xc0023002ac
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *range-terraformer-drone-explo-color* curve-color-fast)
|
|
;; (define-extern *range-terraformer-drone-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-terraformer-drone-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-terraformer-drone-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-terraformer-drone-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-terraformer-drone-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-terraformer-drone-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-terraformer-drone-explosion-texture-curve-settings* object)
|
|
;; (define-extern *terraformer-drone-nav-enemy-info* nav-enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; deswalk-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; deswalk-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dm-urchin (process-drawable)
|
|
((hit-points float :offset-assert 200)
|
|
(incoming-attack-id uint32 :offset-assert 204)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd0
|
|
:flag-assert #x16005000d0
|
|
(:state-methods
|
|
die ;; 20
|
|
idle ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desw-eco-tank (process-drawable)
|
|
((hit-points float :offset-assert 200)
|
|
(incoming-attack-id uint32 :offset-assert 204)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xd0
|
|
:flag-assert #x16005000d0
|
|
(:state-methods
|
|
die ;; 20
|
|
idle ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dm-tentacle-spores (process-focusable)
|
|
((hit-points float :offset-assert 208)
|
|
(incoming-attack-id uint32 :offset-assert 212)
|
|
(attack-timer uint64 :offset-assert 216)
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #xe0
|
|
:flag-assert #x1d006000e0
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dm-tentacle-ragdoll (ragdoll)
|
|
((chain-pos int8 :offset-assert 11980)
|
|
(start-time uint64 :offset-assert 11984)
|
|
(mode uint64 :offset-assert 11992)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x2ee0
|
|
:flag-assert #x1a00002ee0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dm-tentacle-ragdoll-proc (ragdoll-proc)
|
|
((last-frame-time uint64 :offset-assert 136)
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x90
|
|
:flag-assert #x1400100090
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dm-tentacle (process-focusable)
|
|
((hit-points float :offset-assert 208)
|
|
(incoming-attack-id uint32 :offset-assert 212)
|
|
(collision-timer uint64 :offset-assert 216)
|
|
(ragdoll-proc uint64 :offset-assert 224)
|
|
(flags uint32 :offset-assert 232)
|
|
(attack-timer uint64 :offset-assert 240)
|
|
(initial-position vector :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x110
|
|
:flag-assert #x2500900110
|
|
(:methods
|
|
(dm-tentacle-method-36 () none) ;; 36
|
|
)
|
|
(:state-methods
|
|
die ;; 28
|
|
strike ;; 29
|
|
sweep ;; 30
|
|
whip ;; 31
|
|
spit ;; 32
|
|
retract ;; 33
|
|
extend ;; 34
|
|
idle ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dm-tentacle-attack (structure)
|
|
((attack-type uint64 :offset-assert 0)
|
|
(probability float :offset-assert 8)
|
|
(possible basic :offset-assert 12)
|
|
(min-dist float :offset-assert 16)
|
|
(max-dist float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-deswalk (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-deswalk (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desw-snake-stump (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
(up-timer uint64 :offset-assert 204)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xd8
|
|
:flag-assert #x18006000d8
|
|
(:methods
|
|
(desw-snake-stump-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
up ;; 20
|
|
down ;; 22
|
|
moving ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *dm-urchin-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *desw-eco-tank-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern dm-tentacle-spores-init-by-other function)
|
|
;; (define-extern *dm-tentacle-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *dm-tentacle-ragdoll-setup* object)
|
|
;; (define-extern dm-tentacle-ragdoll-proc-init-by-other function)
|
|
;; (define-extern dm-tentacle-adjust-collision function)
|
|
;; (define-extern dm-tentacle-handler function)
|
|
;; (define-extern *dm-tentacle-attacks* array)
|
|
;; (define-extern dm-tentacle-start-ragdoll function)
|
|
;; (define-extern desw-snake-stump-should-be-active? function)
|
|
;; (define-extern desw-snake-stump-should-be-up? function)
|
|
;; (define-extern desw-snake-stump-handler function)
|
|
;; (define-extern partway-up state)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; palroof-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern check-drop-level-palroof-drop-userdata function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; intro-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ctypal-ctyfarma (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; searchlight ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype searchlight (process-drawable)
|
|
((sync sync-eased :inline :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xf4
|
|
:flag-assert #x15008000f4
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; guide-arrow ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype guide-arrow (process-drawable)
|
|
((bob-dir vector :inline :offset-assert 208)
|
|
(base-pos vector :inline :offset-assert 224)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xf8
|
|
:flag-assert #x17008000f8
|
|
(:methods
|
|
(guide-arrow-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype guide-arrow-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(facing vector :inline :offset-assert 16)
|
|
(twist float :offset-assert 32)
|
|
(xz? basic :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
;; (define-extern guide-arrow-init-by-other function)
|
|
;; (define-extern spawn-guide-arrow function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kg-vehicles ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype pickup-sled-sim (billiard-table)
|
|
((mat matrix :inline :offset-assert 96)
|
|
(external-force vector :inline :offset-assert 160)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xb0
|
|
:flag-assert #x10000000b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-kg-pickup (h-car-base)
|
|
((fin-fr joint-mod-rotate-local :inline :offset-assert 960)
|
|
(fin-fl joint-mod-rotate-local :inline :offset-assert 992)
|
|
(fin-r joint-mod-rotate-local :inline :offset-assert 1024)
|
|
(fin-l joint-mod-rotate-local :inline :offset-assert 1056)
|
|
(rudder-l joint-mod-rotate-local :inline :offset-assert 1088)
|
|
(rudder-r joint-mod-rotate-local :inline :offset-assert 1120)
|
|
(turn-rate float :offset-assert 1152)
|
|
(target-turn-rate float :offset-assert 1156)
|
|
(camera-override? basic :offset-assert 1160)
|
|
(initial-creation-time uint64 :offset-assert 1168)
|
|
(auto-boost? basic :offset-assert 1176)
|
|
(steering-val float :offset-assert 1180)
|
|
(sled basic :offset-assert 1184)
|
|
(barrels basic :offset-assert 1188)
|
|
(taskman uint64 :offset-assert 1192)
|
|
(last-jitter-time uint64 :offset-assert 1200)
|
|
(last-slide-time uint64 :offset-assert 1208)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x4c0
|
|
:flag-assert #xa2044004c0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dark-barrel (process-focusable)
|
|
()
|
|
:method-count-assert 29
|
|
:size-assert #xd0
|
|
:flag-assert #x1d005000d0
|
|
(:state-methods
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *hijack-suck-curve* object)
|
|
;; (define-extern compute-suck-speed-scalar function)
|
|
;; (define-extern *h-kg-pickup-constants* object)
|
|
;; (define-extern dark-barrel-init-by-other function)
|
|
;; (define-extern spawn-pickup function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tower-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-dark-tower-explo-color* curve-color-fast)
|
|
;; (define-extern *range-dark-tower-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-dark-tower-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-dark-tower-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-dark-tower-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-dark-tower-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-dark-tower-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-dark-tower-explosion-texture-curve-settings* object)
|
|
;; (define-extern *range-tower-dust-color* curve-color-fast)
|
|
;; (define-extern *range-tower-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-tower-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-tower-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-tower-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-tower-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-tower-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-hellcat-tower-dust-landing-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-hijack ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cty-hijack-manager (task-manager)
|
|
((hpickup uint64 :offset-assert 240)
|
|
(missiles basic :offset-assert 248)
|
|
(current-leader-missile int8 :offset-assert 252)
|
|
(task-arrow uint64 :offset-assert 256)
|
|
(alert-expire-time uint64 :offset-assert 264)
|
|
(lure-hit-time uint64 :offset-assert 280)
|
|
(naughty-ottsel-lure uint64 :offset-assert 288)
|
|
(missile-sound uint32 :offset-assert 296)
|
|
(vehicle-is-visible? basic :offset-assert 300)
|
|
(last-check-vehicle-vis-time uint64 :offset-assert 304)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x138
|
|
:flag-assert #x2900c00138
|
|
(:methods
|
|
(cty-hijack-manager-method-35 () none) ;; 35
|
|
(cty-hijack-manager-method-36 () none) ;; 36
|
|
(cty-hijack-manager-method-37 () none) ;; 37
|
|
(cty-hijack-manager-method-38 () none) ;; 38
|
|
(cty-hijack-manager-method-39 () none) ;; 39
|
|
(cty-hijack-manager-method-40 () none) ;; 40
|
|
)
|
|
(:state-methods
|
|
fail ;; 18
|
|
show-missile-launch ;; 34
|
|
wait ;; 14
|
|
active ;; 15
|
|
decoy-stage ;; 33
|
|
player-riding ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hijack-speech-instance (speech-instance)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hijack-speech-info (structure)
|
|
((speeches basic :offset-assert 0)
|
|
(flags uint64 :offset-assert 8)
|
|
(play-time uint64 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-missile-lure-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(orient quaternion :inline :offset-assert 16)
|
|
(is-naughty-ottsel? basic :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x24
|
|
:flag-assert #x900000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-missile-lure (process-focusable)
|
|
((state-time uint64 :offset-assert 192)
|
|
(minimap connection-minimap :offset-assert 216)
|
|
(is-naughty-ottsel? basic :offset-assert 220)
|
|
(lock-open? basic :offset-assert 224)
|
|
(hum-sound uint32 :offset-assert 228)
|
|
(sirens2 basic :offset-assert 232)
|
|
(raise-sound uint32 :offset-assert 236)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #xf0
|
|
:flag-assert #x25007000f0
|
|
(:methods
|
|
(cty-missile-lure-method-35 () none) ;; 35
|
|
(cty-missile-lure-method-36 () none) ;; 36
|
|
)
|
|
(:state-methods
|
|
naughty-ottsel-lure ;; 34
|
|
naughty-ottsel-wait ;; 33
|
|
idle ;; 28
|
|
complete ;; 30
|
|
opening ;; 32
|
|
closing ;; 31
|
|
active ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-lure-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-missile-launcher (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
recoil ;; 21
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype guide-arrow-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(facing vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *cty-hijack-speech-list* object)
|
|
;; (define-extern *pickup-start-pos* object)
|
|
;; (define-extern *pickup-start-angle* object)
|
|
;; (define-extern *hijack-speech* array)
|
|
;; (define-extern debug-reset-hijack-speech function)
|
|
;; (define-extern cty-missile-lure-init-by-other function)
|
|
;; (define-extern *cty-hijack-lure-positions* array)
|
|
;; (define-extern *naughty-ottsel-pos* object)
|
|
;; (define-extern *ctyport-hijack-fail* object)
|
|
;; (define-extern *pre-hijack-kg-squad-member-settings* object)
|
|
;; (define-extern *post-hijack-kg-squad-member-settings* object)
|
|
;; (define-extern *missile-fire-order* array)
|
|
;; (define-extern *missile-fire-frames* array)
|
|
;; (define-extern *missile-closer-chase-normal* object)
|
|
;; (define-extern *missile-closer-chase-pos* object)
|
|
;; (define-extern *guide-arrow-list* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; for-turret-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype for-turret-shot (projectile)
|
|
((tail-pos vector :inline :offset-assert 512)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x210
|
|
:flag-assert #x2901900210
|
|
)
|
|
|#
|
|
|
|
;; (define-extern for-turret-shot-move function)
|
|
;; (define-extern spawn-for-turret-projectile function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; for-turret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; hud-for-turret-health is already defined!
|
|
|
|
#|
|
|
(deftype for-turret-blocker (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-turret (target-turret)
|
|
((aim-pos vector :inline :offset-assert 556)
|
|
(muzzle-pos vector :inline :offset-assert 572)
|
|
(battle-entity basic :offset-assert 588)
|
|
(focus-handle uint64 :offset-assert 596)
|
|
(task-node-id int32 :offset-assert 604)
|
|
(fire-timer uint64 :offset-assert 612)
|
|
(nav-mesh basic :offset-assert 620)
|
|
(flash-palette-index int32 :offset-assert 624)
|
|
(flash-palette-level basic :offset-assert 628)
|
|
(blocker uint64 :offset-assert 636)
|
|
(actor-group uint32 :offset-assert 644)
|
|
(actor-group-count int32 :offset-assert 648)
|
|
(last-speed0 float :offset-assert 652)
|
|
(minimap connection-minimap :offset-assert 656)
|
|
(current-barrel int32 :offset-assert 660)
|
|
(barrel-recoil-offset UNKNOWN 2 :offset-assert 664)
|
|
)
|
|
:method-count-assert 61
|
|
:size-assert #x2a4
|
|
:flag-assert #x3d023002a4
|
|
(:state-methods
|
|
idle ;; 28
|
|
gunner-active ;; 60
|
|
setup ;; 29
|
|
gunner-setup ;; 59
|
|
active ;; 30
|
|
shutdown ;; 31
|
|
die ;; 33
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern for-turret-blocker-init-by-other function)
|
|
;; (define-extern *for-turret-params* object)
|
|
;; (define-extern *for-turret-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *for-turret-offset-table* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; neo-wasp ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype neo-wasp-shot (metalhead-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x210
|
|
:flag-assert #x2901900210
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-wasp (hover-enemy)
|
|
((gun-jmod joint-mod-rotate-local :inline :offset-assert 976)
|
|
(entity-group basic :offset-assert 1008)
|
|
(smoke-part basic :offset-assert 1012)
|
|
(engine-part basic :offset-assert 1016)
|
|
(minimap connection-minimap :offset-assert 1020)
|
|
(old-gravity float :offset-assert 1028)
|
|
(knocked-anim int32 :offset-assert 1032)
|
|
(knocked-recover-anim int32 :offset-assert 1036)
|
|
(last-fire-time uint64 :offset-assert 1040)
|
|
(bridge-index int32 :offset-assert 1048)
|
|
(gun-x-angle float :offset-assert 1052)
|
|
(gun-x-angle-final float :offset-assert 1056)
|
|
(path-u float :offset-assert 1060)
|
|
(path-du float :offset-assert 1064)
|
|
(path-du-final float :offset-assert 1068)
|
|
(path-dest float :offset-assert 1072)
|
|
(plat-pos vector :inline :offset-assert 1088)
|
|
(sound-id uint32 :offset-assert 1104)
|
|
(on-screen-timer uint64 :offset-assert 1112)
|
|
(attack-wait-min float :offset-assert 1120)
|
|
(attack-wait-max float :offset-assert 1124)
|
|
(attack-miss-dist-min float :offset-assert 1128)
|
|
(attack-miss-dist-max float :offset-assert 1132)
|
|
(attack-miss-dist-curr float :offset-assert 1136)
|
|
(mech-flame-texture-id uint32 :offset-assert 1140)
|
|
)
|
|
:method-count-assert 185
|
|
:size-assert #x478
|
|
:flag-assert #xb904000478
|
|
(:methods
|
|
(neo-wasp-method-182 () none) ;; 182
|
|
(neo-wasp-method-183 () none) ;; 183
|
|
(neo-wasp-method-184 () none) ;; 184
|
|
)
|
|
(:state-methods
|
|
ambush ;; 47
|
|
ambush-flying ;; 177
|
|
attack ;; 179
|
|
notice ;; 35
|
|
hostile ;; 38
|
|
ambush-attack ;; 178
|
|
knocked-recover ;; 32
|
|
die-explode ;; 181
|
|
die-now ;; 180
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-wasp-spawner (process)
|
|
((spawn-pos vector :inline :offset-assert 128)
|
|
(spawn-timer uint64 :offset-assert 144)
|
|
(enemies-spawned int32 :offset-assert 152)
|
|
(enemies-to-spawn int32 :offset-assert 156)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xa0
|
|
:flag-assert #x10002000a0
|
|
(:state-methods
|
|
idle ;; 14
|
|
die ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *neo-wasp-debris-params* debris-static-params)
|
|
;; (define-extern *fact-info-neo-wasp-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *neo-wasp-enemy-info* enemy-info)
|
|
;; (define-extern neo-wasp-spawner-event-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-foresta ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *foresta-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prebot-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-prebot (task-manager)
|
|
((manager-entity basic :offset-assert 240)
|
|
(check-timer uint64 :offset-assert 248)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x100
|
|
:flag-assert #x2000800100
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern prebot-neck-callback function)
|
|
;; (define-extern prebot-light-pulse-off function)
|
|
;; (define-extern prebot-light-pulse-on function)
|
|
;; (define-extern prebot-light-flash function)
|
|
;; (define-extern prebot-prespool function)
|
|
;; (define-extern prebot-common function)
|
|
;; (define-extern prebot-go-next-stage function)
|
|
;; (define-extern prebot-handler function)
|
|
;; (define-extern prebot-set-cam-slave-fov function)
|
|
;; (define-extern prebot-setup-shot-offsets function)
|
|
;; (define-extern prebot-fire-tentacle function)
|
|
;; (define-extern prebot-launch-critter function)
|
|
;; (define-extern prebot-spawn-shockwave function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; neo-spawner ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-neo-spawner-health (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-spawner-manager (process)
|
|
((actor-group uint32 :offset-assert 124)
|
|
(actor-group-count int32 :offset-assert 128)
|
|
(total-spawned int32 :offset-assert 132)
|
|
(max-spawned int32 :offset-assert 136)
|
|
(suppress-spawn basic :offset-assert 140)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x94
|
|
:flag-assert #xf00200094
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-spawner-type (structure)
|
|
((spawn-type basic :offset-assert 0)
|
|
(count uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype neo-spawner (process-focusable)
|
|
((info basic :offset-assert 208)
|
|
(actor-group uint32 :offset-assert 212)
|
|
(actor-group-count int32 :offset-assert 216)
|
|
(manager-entity basic :offset-assert 220)
|
|
(turret-entity basic :offset-assert 224)
|
|
(minimap connection-minimap :offset-assert 228)
|
|
(incoming-attack-id int32 :offset-assert 232)
|
|
(health float :offset-assert 236)
|
|
(health-hud-timer float :offset-assert 240)
|
|
(open-time uint64 :offset-assert 248)
|
|
(triggered? basic :offset-assert 256)
|
|
(hud-health uint64 :offset-assert 264)
|
|
(lightning-time uint64 :offset-assert 272)
|
|
(dead-part basic :offset-assert 280)
|
|
(last-spawn-time uint64 :offset-assert 288)
|
|
(state-time uint64 :offset-assert 192)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x130
|
|
:flag-assert #x2500b00130
|
|
(:methods
|
|
(neo-spawner-method-35 () none) ;; 35
|
|
(neo-spawner-method-36 () none) ;; 36
|
|
)
|
|
(:state-methods
|
|
closed ;; 28
|
|
opening ;; 29
|
|
open ;; 30
|
|
spawn-enemy ;; 31
|
|
vulnerable ;; 32
|
|
die ;; 33
|
|
dead ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern foresta-login function)
|
|
;; (define-extern foresta-logout function)
|
|
;; (define-extern foresta-activate function)
|
|
;; (define-extern *neo-spawner-info* array)
|
|
;; (define-extern *neo-spawner-debris-params* debris-static-params)
|
|
;; (define-extern neo-spawner-handler function)
|
|
;; (define-extern neo-spawner-active-post function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; race-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype race-turbo-pad (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(handle uint64 :offset-assert 16) ;; handle
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-decision-point (structure)
|
|
((pos float :offset-assert 0)
|
|
(decision-type uint8 :offset-assert 4)
|
|
(shortcuts uint8 :offset-assert 5)
|
|
(safe-paths uint8 :offset-assert 6)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x7
|
|
:flag-assert #x900000007
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-racer-info (structure)
|
|
((rider uint8 :offset-assert 0)
|
|
(vehicle uint8 :offset-assert 1)
|
|
(flags uint8 :offset-assert 2) ;; racer-info-flags
|
|
(seek-offset int8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-info (basic)
|
|
((race-mesh-name string :offset-assert 4) ;; guessed by decompiler
|
|
(path-group-name string :offset-assert 8) ;; guessed by decompiler
|
|
(task-node uint16 :offset-assert 12) ;; game-task-node
|
|
(mesh race-mesh :offset-assert 16) ;; guessed by decompiler
|
|
(ai-min-speed-factor float :offset-assert 20)
|
|
(ai-max-speed-factor float :offset-assert 24)
|
|
(ai-spread-factor float :offset-assert 28)
|
|
(start-sphere sphere :inline :offset-assert 32)
|
|
(start-dir vector :inline :offset-assert 48)
|
|
(finish-sphere sphere :inline :offset-assert 64)
|
|
(finish-dir vector :inline :offset-assert 80)
|
|
(player-intro-pos vector :inline :offset-assert 96)
|
|
(flags uint8 :offset-assert 112) ;; race-info-flags
|
|
(score uint8 :offset-assert 113)
|
|
(lap-count int8 :offset-assert 114)
|
|
(racer-count int8 :offset-assert 115)
|
|
(turbo-pad-count int8 :offset-assert 116)
|
|
(map-index int8 :offset-assert 117)
|
|
(decision-point-count int8 :offset-assert 118)
|
|
(safe-paths uint8 :offset-assert 119)
|
|
(turbo-pad-array (inline-array race-turbo-pad) :offset-assert 120) ;; guessed by decompiler
|
|
(racer-array (inline-array race-racer-info) :offset-assert 124) ;; guessed by decompiler
|
|
(decision-point-array (inline-array race-decision-point) :offset-assert 128) ;; guessed by decompiler
|
|
(level symbol :offset-assert 132) ;; guessed by decompiler
|
|
(borrow-level symbol :offset-assert 136) ;; guessed by decompiler
|
|
(borrow pair :offset-assert 140) ;; guessed by decompiler
|
|
(manager uint64 :offset-assert 144) ;; handle
|
|
(manager-handle-init-hack basic :offset-assert 144)
|
|
(hatch-actor-name string :offset-assert 152) ;; guessed by decompiler
|
|
(countdown-scene string :offset-assert 156) ;; guessed by decompiler
|
|
(complete-continue string :offset-assert 160) ;; guessed by decompiler
|
|
(start-camera string :offset-assert 164) ;; guessed by decompiler
|
|
(go-speech uint16 :offset-assert 168)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #xaa
|
|
:flag-assert #xa000000aa
|
|
;; field borrow uses ~A with a signed load.
|
|
(:methods
|
|
(race-info-method-9 () none) ;; 9 ;; (initialize-mesh (_type_) none 9)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype racer-state (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(racer uint64 :offset-assert 16) ;; handle
|
|
(flags uint8 :offset-assert 24) ;; racer-flags
|
|
(rank int8 :offset-assert 25)
|
|
(finish-count int8 :offset-assert 26)
|
|
(lap-count int8 :offset-assert 27)
|
|
(lap-quadrant int8 :offset-assert 28)
|
|
(rider uint8 :offset-assert 29)
|
|
(lap-distance float :offset-assert 32)
|
|
(lap-distance-prev float :offset-assert 36)
|
|
(pos float :offset-assert 40)
|
|
(target-pos-offset float :offset-assert 44)
|
|
(speed-factor float :offset-assert 48)
|
|
(finish-time uint32 :offset-assert 52)
|
|
(lap-start uint32 :offset-assert 56)
|
|
(best-lap-time uint32 :offset-assert 60)
|
|
(lap-time-array float 5 :offset-assert 64) ;; guessed by decompiler
|
|
(start-position vector :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x70
|
|
:flag-assert #xe00000070
|
|
(:methods
|
|
(racer-state-method-9 () none) ;; 9 ;; (update-lap-distance (_type_ race-state) none 9)
|
|
(racer-state-method-10 () none) ;; 10 ;; (begin-lap (_type_ race-state) none 10)
|
|
(racer-state-method-11 () none) ;; 11 ;; (end-lap (_type_ race-state) none 11)
|
|
(racer-state-method-12 () none) ;; 12 ;; (print-laps (_type_ race-state string) none 12)
|
|
(racer-state-method-13 () none) ;; 13 ;; (init-racer! (_type_ process-drawable) none 13)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-state (structure)
|
|
((info race-info :offset-assert 0) ;; guessed by decompiler
|
|
(flags uint8 :offset-assert 4) ;; race-flags
|
|
(state uint8 :offset-assert 5) ;; race-state-enum
|
|
(racer-count int8 :offset-assert 6)
|
|
(finished-count int8 :offset-assert 7)
|
|
(i-player int8 :offset-assert 8)
|
|
(i-countdown int8 :offset-assert 9)
|
|
(manager uint64 :offset-assert 16) ;; handle
|
|
(scene-player uint64 :offset-assert 24) ;; handle
|
|
(race-signal uint64 :offset-assert 32) ;; handle
|
|
(arrow uint64 :offset-assert 40) ;; handle
|
|
(hud-timer uint64 :offset-assert 48) ;; handle
|
|
(hud-lap-counter uint64 :offset-assert 56) ;; handle
|
|
(hud-turbo-counter uint64 :offset-assert 64) ;; handle
|
|
(hud-position uint64 :offset-assert 72) ;; handle
|
|
(current-time uint32 :offset-assert 80)
|
|
(countdown-start-time uint32 :offset-assert 84)
|
|
(race-start-time uint32 :offset-assert 88)
|
|
(rankings int8 10 :offset-assert 92) ;; guessed by decompiler
|
|
(target-pos float :offset-assert 104)
|
|
(suck-factor float :offset-assert 108)
|
|
(player-win? basic :offset-assert 112)
|
|
(new-score? basic :offset-assert 116)
|
|
(racer-array racer-state 10 :offset-assert 128) ;; guessed by decompiler
|
|
(player-intro-curve cubic-curve :inline :offset-assert 1248)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x520
|
|
:flag-assert #x1500000520
|
|
(:methods
|
|
(race-state-method-9 () none) ;; 9 ;; (init-racers! (_type_ process-drawable) none 9)
|
|
(race-state-method-10 () none) ;; 10 ;; (begin-race (_type_) none 10)
|
|
(race-state-method-11 () none) ;; 11 ;; (update (_type_) none 11)
|
|
(race-state-method-12 () none) ;; 12 ;; (update-rankings (_type_) none 12)
|
|
(race-state-method-13 () none) ;; 13 ;; (debug-print-rankings (_type_) none 13)
|
|
(race-state-method-14 () none) ;; 14 ;; (update-racers (_type_) none 14)
|
|
(race-state-method-15 () none) ;; 15 ;; (spawn-race-signal (_type_) none 15)
|
|
(race-state-method-16 () none) ;; 16 ;; (initialize (_type_ process race-info) none 16)
|
|
(race-state-method-17 () none) ;; 17 ;; (set-speech-tables! (_type_) none 17)
|
|
(race-state-method-18 () none) ;; 18 ;; (setup-race (_type_) none 18)
|
|
(race-state-method-19 () none) ;; 19
|
|
(race-state-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-manager (process)
|
|
((race-state race-state :offset-assert 128)
|
|
(state-time uint64 :offset-assert 136) ;; time-frame
|
|
(player-on-track-time uint64 :offset-assert 144) ;; time-frame
|
|
(message-id sound-id :offset-assert 152) ;; guessed by decompiler
|
|
(finish-sound-id sound-id :offset-assert 156) ;; guessed by decompiler
|
|
(show-stats? basic :offset-assert 160)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #xa4
|
|
:flag-assert #x1c003000a4
|
|
(:methods
|
|
(race-manager-method-14 () none) ;; 14 ;; (idle () _type_ :state 14)
|
|
(race-manager-method-15 () none) ;; 15 ;; (active () _type_ :state 15)
|
|
(race-manager-method-16 () none) ;; 16 ;; (fail () _type_ :state 16)
|
|
(race-manager-method-17 () none) ;; 17 ;; (win () _type_ :state 17)
|
|
(race-manager-method-18 () none) ;; 18 ;; (lose () _type_ :state 18)
|
|
(race-manager-method-19 () none) ;; 19 ;; (die () _type_ :state 19)
|
|
(race-manager-method-20 () none) ;; 20 ;; (update (_type_) int 20)
|
|
(race-manager-method-21 () none) ;; 21 ;; (initialize-state (_type_) none 21)
|
|
(race-manager-method-22 () none) ;; 22 ;; (race-manager-method-22 (_type_) none 22)
|
|
(race-manager-method-23 () none) ;; 23 ;; (initialize-race-state (_type_) none 23)
|
|
(race-manager-method-24 () none) ;; 24 ;; (draw-message-continue (_type_) none 24)
|
|
(race-manager-method-25 () none) ;; 25 ;; (draw-message-retry (_type_) none 25)
|
|
(race-manager-method-26 () none) ;; 26 ;; (save-score (_type_ float) none 26)
|
|
(race-manager-method-27 () none) ;; 27 ;; (stop-speech (_type_) none 27)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-race-timer (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-race-lap-counter (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-race-turbo-counter (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-race-position (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *race-manager* object) ;; (pointer race-manager)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; was-leaper-race ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wascity-race-ring (process-drawable)
|
|
((active? basic :offset-assert 200)
|
|
(mat matrix :inline :offset-assert 208)
|
|
(taskman uint64 :offset-assert 272)
|
|
(player-part basic :offset-assert 280)
|
|
(player-ring? basic :offset-assert 284)
|
|
(minimap connection-minimap :offset-assert 288)
|
|
(is-final? basic :offset-assert 292)
|
|
(part-final basic :offset-assert 296)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x12c
|
|
:flag-assert #x1800b0012c
|
|
(:methods
|
|
(wascity-race-ring-method-22 () none) ;; 22
|
|
(wascity-race-ring-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-wascity-leaper-race (task-manager)
|
|
((ring-manager-entity basic :offset-assert 236)
|
|
(actor-group uint32 :offset-assert 240)
|
|
(actor-group-count int32 :offset-assert 244)
|
|
(current-ring uint8 :offset-assert 248)
|
|
(challenger-current-ring UNKNOWN 3 :offset-assert 249)
|
|
(check-timer uint64 :offset-assert 252)
|
|
(hud-position uint64 :offset-assert 212)
|
|
(hint-timer uint64 :offset-assert 260)
|
|
(played-speeches uint32 :offset-assert 268)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x114
|
|
:flag-assert #x2300a00114
|
|
(:methods
|
|
(task-manager-wascity-leaper-race-method-32 () none) ;; 32
|
|
(task-manager-wascity-leaper-race-method-33 () none) ;; 33
|
|
(task-manager-wascity-leaper-race-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
fail ;; 18
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern wascity-race-ring-cleared? function)
|
|
;; (define-extern *was-leaper-speech-list* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; race-mesh ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype race-mesh-hash-search (structure)
|
|
((best-dist float :offset-assert 0)
|
|
(debug-cells-searched int32 :offset-assert 4)
|
|
(debug-slices-searched int32 :offset-assert 8)
|
|
(bounds bounding-box4w :inline :offset-assert 16)
|
|
(cell-quads vector 2 :offset-assert 48) ;; guessed by decompiler
|
|
(slice-quads vector 4 :offset-assert 80) ;; guessed by decompiler
|
|
(cell-bits vector16ub 2 :offset-assert 48) ;; guessed by decompiler
|
|
(slice-bits vector16ub 2 :offset-assert 80) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-mesh-slice-query (structure)
|
|
((slice-id int16 :offset-assert 0)
|
|
(lap-dist float :offset-assert 4)
|
|
(pt-on-slice vector :inline :offset-assert 16)
|
|
(slice-corners vector 4 :offset-assert 32) ;; guessed by decompiler
|
|
(search-sphere sphere :inline :offset-assert 96)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x70
|
|
:flag-assert #x900000070
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-path-edge-info (structure)
|
|
((sample-t float :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-path-sample (structure)
|
|
((bytes uint8 32 :offset-assert 0) ;; guessed by decompiler
|
|
(pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(stick-x int8 :offset-assert 12)
|
|
(stick-y int8 :offset-assert 13)
|
|
(throttle uint8 :offset-assert 14)
|
|
(flags uint8 :offset-assert 15)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-path (structure)
|
|
((sample-count uint16 :offset-assert 0)
|
|
(record-id int8 :offset-assert 2)
|
|
(pad uint8 :offset-assert 3)
|
|
(samples (inline-array race-path-sample) :offset-assert 4) ;; guessed by decompiler
|
|
(edge-infos (inline-array race-path-edge-info) :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #xc
|
|
:flag-assert #xd0000000c
|
|
(:methods
|
|
(race-path-method-9 () none) ;; 9 ;; (draw-path-debug (_type_ rgba rgba) none 9)
|
|
(race-path-method-10 () none) ;; 10 ;; (race-path-method-10 (_type_ vector float float) none 10)
|
|
(race-path-method-11 () none) ;; 11 ;; (race-path-method-11 (_type_ race-path-sample vector float) none 11)
|
|
(race-path-method-12 () none) ;; 12 ;; (race-path-method-12 (_type_ vector float float) float 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-path-group (structure)
|
|
((name string :offset-assert 0) ;; guessed by decompiler
|
|
(path-count int8 :offset-assert 4)
|
|
(pad uint8 3 :offset-assert 5) ;; guessed by decompiler
|
|
(paths (inline-array race-path) :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-mesh-edge (structure)
|
|
((left vector :inline :offset-assert 0)
|
|
(right vector :inline :offset-assert 16)
|
|
(lap-dist float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-mesh-slice (structure)
|
|
((edge-index-array uint16 2 :offset-assert 0) ;; guessed by decompiler
|
|
(start-edge int16 :offset-assert 0)
|
|
(end-edge int16 :offset-assert 2)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-mesh-hash-cell (structure)
|
|
((first-slice int16 :offset-assert 0)
|
|
(slice-count uint8 :offset-assert 2)
|
|
(pad uint8 :offset-assert 3)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-mesh-hash (structure)
|
|
((cells-wide int8 :offset-assert 0)
|
|
(cells-tall int8 :offset-assert 1)
|
|
(cell-length float :offset-assert 4)
|
|
(cells (inline-array race-mesh-hash-cell) :offset-assert 8) ;; guessed by decompiler
|
|
(slice-table (inline-array race-mesh-slice) :offset-assert 12) ;; guessed by decompiler
|
|
(origin vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype race-mesh (basic)
|
|
((version uint8 :offset-assert 4)
|
|
(path-group-count uint8 :offset-assert 5)
|
|
(flags uint8 :offset-assert 6) ;; race-mesh-flags
|
|
(pad uint8 1 :offset-assert 7) ;; guessed by decompiler
|
|
(slice-count int16 :offset-assert 8)
|
|
(edge-count int16 :offset-assert 10)
|
|
(slices (inline-array race-mesh-slice) :offset-assert 12) ;; guessed by decompiler
|
|
(edges (inline-array race-mesh-edge) :offset-assert 16) ;; guessed by decompiler
|
|
(hash race-mesh-hash :offset-assert 20)
|
|
(path-groups (inline-array race-path-group) :offset-assert 24) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 20
|
|
:size-assert #x1c
|
|
:flag-assert #x140000001c
|
|
(:methods
|
|
(race-mesh-method-9 () none) ;; 9 ;; (debug-draw-path (_type_ int int rgba rgba) none 9)
|
|
(race-mesh-method-10 () none) ;; 10 ;; (debug-draw-path-from-history (_type_ int int) symbol 10)
|
|
(race-mesh-method-11 () none) ;; 11 ;; (debug-draw-slice (_type_ int) none 11)
|
|
(race-mesh-method-12 () none) ;; 12 ;; (debug-draw-edges (_type_) none 12)
|
|
(race-mesh-method-13 () none) ;; 13 ;; (race-mesh-method-13 (_type_ race-mesh-slice-query) none 13)
|
|
(race-mesh-method-14 () none) ;; 14 ;; (race-mesh-method-14 (_type_ race-mesh-slice-query) none 14)
|
|
(race-mesh-method-15 () none) ;; 15 ;; (race-mesh-method-15 (_type_ int race-mesh-slice-query) none 15)
|
|
(race-mesh-method-16 () none) ;; 16 ;; (race-mesh-method-16 (_type_ race-mesh-slice-query) none 16)
|
|
(race-mesh-method-17 () none) ;; 17 ;; (race-mesh-method-17 (_type_ race-mesh-slice-query) symbol 17)
|
|
(race-mesh-method-18 () none) ;; 18 ;; (race-mesh-method-18 (_type_ race-mesh-hash-search int int race-mesh-slice-query) none 18)
|
|
(race-mesh-method-19 () none) ;; 19 ;; (race-mesh-method-19 (_type_ int race-mesh-slice-query) symbol 19)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; race-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype race-control (structure)
|
|
((state race-state :offset-assert 0)
|
|
(mesh race-mesh :offset-assert 4) ;; guessed by decompiler
|
|
(path-select int8 :offset-assert 8)
|
|
(path-group race-path-group :offset-assert 12)
|
|
(path race-path :offset-assert 16)
|
|
(path-t float :offset-assert 20)
|
|
(racer-state racer-state :offset-assert 24)
|
|
(path-sample race-path-sample :inline :offset-assert 32)
|
|
(lin-velocity vector :inline :offset-assert 64)
|
|
(ang-velocity vector :inline :offset-assert 80)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x60
|
|
:flag-assert #xd00000060
|
|
(:methods
|
|
(race-control-method-9 () none) ;; 9 ;; (race-control-method-9 (_type_ int vector) none 9)
|
|
(race-control-method-10 () none) ;; 10 ;; (race-control-method-10 (_type_ race-state racer-state) none 10)
|
|
(race-control-method-11 () none) ;; 11 ;; (race-control-method-11 (_type_ float) none 11)
|
|
(race-control-method-12 () none) ;; 12 ;; (race-control-method-12 (_type_ vector) none 12)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; race-info ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *race-info-array* array) ;; (array race-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blow-tower-obs2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bt-roboguard (blow-tower-enemy)
|
|
((focus-pos vector :inline :offset-assert 256)
|
|
(focus uint64 :offset-assert 272)
|
|
(rotation-matrix matrix :inline :offset-assert 288)
|
|
(me-to-focus-dir vector :inline :offset-assert 352)
|
|
(me-to-focus-angle float :offset-assert 368)
|
|
(torso-aim-blend float :offset-assert 372)
|
|
(torso-angle float :offset-assert 376)
|
|
(torso-seek-speed float :offset-assert 380)
|
|
(torso-to-focus-angle float :offset-assert 384)
|
|
(last-torso-frame-num float :offset-assert 388)
|
|
(stand-angle-threshold float :offset-assert 392)
|
|
(fire-time uint64 :offset-assert 400)
|
|
(fire-count int8 :offset-assert 408)
|
|
(fire-delay uint64 :offset-assert 416)
|
|
(path-clock-time uint64 :offset-assert 424)
|
|
(difficulty float :offset-assert 432)
|
|
(active-clock-time uint64 :offset-assert 440)
|
|
)
|
|
:method-count-assert 47
|
|
:size-assert #x1c0
|
|
:flag-assert #x2f014001c0
|
|
(:methods
|
|
(bt-roboguard-method-40 () none) ;; 40
|
|
(bt-roboguard-method-41 () none) ;; 41
|
|
(bt-roboguard-method-42 () none) ;; 42
|
|
(bt-roboguard-method-43 () none) ;; 43
|
|
(bt-roboguard-method-44 () none) ;; 44
|
|
(bt-roboguard-method-45 () none) ;; 45
|
|
(bt-roboguard-method-46 () none) ;; 46
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
hostile-stand ;; 38
|
|
shoot-attack ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-roboguard-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-flyer (tower-flyer)
|
|
()
|
|
:method-count-assert 50
|
|
:size-assert #x2b0
|
|
:flag-assert #x32023002b0
|
|
(:state-methods
|
|
charging ;; 39
|
|
firing ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-mh-flyer (tower-flyer)
|
|
((rotation-vec vector :inline :offset-assert 688)
|
|
(xz-dir vector :inline :offset-assert 704)
|
|
(main-joint-movement UNKNOWN 3 :offset-assert 720)
|
|
(thrust UNKNOWN 2 :offset-assert 768)
|
|
(engine-part basic :offset-assert 776)
|
|
)
|
|
:method-count-assert 53
|
|
:size-assert #x30c
|
|
:flag-assert #x350290030c
|
|
(:methods
|
|
(bt-mh-flyer-method-50 () none) ;; 50
|
|
(bt-mh-flyer-method-51 () none) ;; 51
|
|
(bt-mh-flyer-method-52 () none) ;; 52
|
|
)
|
|
(:state-methods
|
|
hovering ;; 38
|
|
charging ;; 39
|
|
fleeing ;; 41
|
|
firing ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-grunt (blow-tower-enemy)
|
|
((target uint64 :offset-assert 256)
|
|
(last-parent-xform matrix :inline :offset-assert 272)
|
|
(idle-time uint64 :offset-assert 336)
|
|
(rider-index int16 :offset-assert 344)
|
|
(start-pos vector :inline :offset-assert 352)
|
|
(jump-cursor blow-tower-path-cursor :inline :offset-assert 368)
|
|
(jump-start-pos vector :inline :offset-assert 496)
|
|
(jump-start-quat quaternion :inline :offset-assert 512)
|
|
(jump-end-pos vector :inline :offset-assert 528)
|
|
(jump-end-quat quaternion :inline :offset-assert 544)
|
|
(apex-height float :offset-assert 560)
|
|
(total-jump-time uint64 :offset-assert 568)
|
|
(jump-start-time uint64 :offset-assert 576)
|
|
(jump-height-percentage-start float :offset-assert 584)
|
|
(jump-height-percentage-end float :offset-assert 588)
|
|
(jump-time-offset float :offset-assert 592)
|
|
(ragdoll-proc uint64 :offset-assert 600)
|
|
(no-real-rider? basic :offset-assert 608)
|
|
(jump-time-scalar float :offset-assert 612)
|
|
(start-ride-time uint64 :offset-assert 616)
|
|
(hit-sound uint32 :offset-assert 624)
|
|
(breathe-sound uint32 :offset-assert 628)
|
|
(landed-on-player? basic :offset-assert 632)
|
|
)
|
|
:method-count-assert 55
|
|
:size-assert #x27c
|
|
:flag-assert #x370200027c
|
|
(:methods
|
|
(bt-grunt-method-46 () none) ;; 46
|
|
(bt-grunt-method-47 () none) ;; 47
|
|
(bt-grunt-method-48 () none) ;; 48
|
|
(bt-grunt-method-49 () none) ;; 49
|
|
(bt-grunt-method-50 () none) ;; 50
|
|
(bt-grunt-method-51 () none) ;; 51
|
|
(bt-grunt-method-52 () none) ;; 52
|
|
(bt-grunt-method-53 () none) ;; 53
|
|
(bt-grunt-method-54 () none) ;; 54
|
|
)
|
|
(:state-methods
|
|
riding-idle-ship ;; 44
|
|
idle ;; 28
|
|
waiting-to-jump ;; 38
|
|
jumping-start ;; 43
|
|
jumping ;; 42
|
|
riding-land ;; 39
|
|
riding-idle ;; 40
|
|
riding-attack ;; 41
|
|
dormant ;; 29
|
|
ragdolled ;; 45
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-missile (blow-tower-enemy)
|
|
((xforms UNKNOWN 4 :offset-assert 256)
|
|
(parent-xform xform :inline :offset-assert 256)
|
|
(last-parent-quat quaternion :inline :offset-assert 448)
|
|
(local-xform xform :inline :offset-assert 304)
|
|
(base-y float :offset-assert 464)
|
|
(bob-xform xform :inline :offset-assert 352)
|
|
(bob-orient xform :inline :offset-assert 400)
|
|
(bobbers UNKNOWN 3 :offset-assert 472)
|
|
(target uint64 :offset-assert 760)
|
|
(chase-start-time uint64 :offset-assert 768)
|
|
(chase-end-time uint64 :offset-assert 776)
|
|
(chase-start-dist float :offset-assert 784)
|
|
(preferred-height-offset float :offset-assert 788)
|
|
(particle-trail basic :offset-assert 792)
|
|
(travel-sound uint32 :offset-assert 796)
|
|
(dumb-fire? basic :offset-assert 800)
|
|
(dumb-speed float :offset-assert 804)
|
|
(dumb-start vector :inline :offset-assert 816)
|
|
(dumb-dest vector :inline :offset-assert 832)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x350
|
|
:flag-assert #x2902d00350
|
|
(:methods
|
|
(bt-missile-method-40 () none) ;; 40
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
chasing ;; 38
|
|
explode ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kg-bombbot (bombbot)
|
|
((start-time uint64 :offset-assert 1512)
|
|
)
|
|
:method-count-assert 209
|
|
:size-assert #x5f0
|
|
:flag-assert #xd1057005f0
|
|
(:state-methods
|
|
hostile ;; 38
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern bt-roboguard-init-by-other function)
|
|
;; (define-extern bt-roboguard-turret-code function)
|
|
;; (define-extern bt-roboguard-turn-torso-post function)
|
|
;; (define-extern spawn-bt-roboguard-projectile function)
|
|
;; (define-extern bt-roboguard-fire-backcheck function)
|
|
;; (define-extern bt-mh-flyer-flight-code function)
|
|
;; (define-extern bt-grunt-init-by-other function)
|
|
;; (define-extern bt-grunt-idle-code function)
|
|
;; (define-extern *grunt-jump-curve* object)
|
|
;; (define-extern *grunt-dists* object)
|
|
;; (define-extern grunt-part-callback function)
|
|
;; (define-extern *grunt-idle-shift* curve2d-fast)
|
|
;; (define-extern bt-missile-init-by-other function)
|
|
;; (define-extern kg-bombbot-find-nearest-nav-mesh function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; comba-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern comba-login function)
|
|
;; (define-extern comba-activate function)
|
|
;; (define-extern comba-deactivate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; race-hud ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flut-racer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flut-racer (nav-enemy)
|
|
((current-ring uint8 :offset-assert 620)
|
|
(taskman uint64 :offset-assert 624)
|
|
(minimap connection-minimap :offset-assert 632)
|
|
(probe vector :inline :offset-assert 640)
|
|
(last-speed-update uint64 :offset-assert 656)
|
|
)
|
|
:method-count-assert 193
|
|
:size-assert #x298
|
|
:flag-assert #xc102200298
|
|
(:state-methods
|
|
wait ;; 190
|
|
race ;; 191
|
|
jump ;; 44
|
|
halt ;; 192
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *flut-racer-enemy-info* nav-enemy-info)
|
|
;; (define-extern ring-hit-logic function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-boss-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-factory-boss-shot-explo-color* curve-color-fast)
|
|
;; (define-extern *range-factory-boss-shot-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-factory-boss-shot-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-factory-boss-shot-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-factory-boss-shot-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-factory-boss-shot-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-factory-boss-shot-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-factory-boss-shot-explosion-texture-curve-settings* object)
|
|
;; (define-extern *part-factory-boss-machine-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; missile-bot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype missile-bot (nav-enemy)
|
|
((traj trajectory :inline :offset-assert 624)
|
|
(initial-y float :offset-assert 664)
|
|
(top-spin-jm basic :offset-assert 668)
|
|
(top-angle float :offset-assert 672)
|
|
(main-jm basic :offset-assert 676)
|
|
(height-bob bouncing-float :inline :offset-assert 680)
|
|
(height-bob-rand delayed-rand-float :inline :offset-assert 720)
|
|
(main-wobble oscillating-vector :inline :offset-assert 752)
|
|
(main-wobble-rand delayed-rand-vector :inline :offset-assert 816)
|
|
(thruster-part basic :offset-assert 864)
|
|
(lightning UNKNOWN 6 :offset-assert 868)
|
|
(lightning-wobble UNKNOWN 3 :offset-assert 896)
|
|
(lightning-wobble-rand UNKNOWN 3 :offset-assert 1088)
|
|
(lightning-mode uint64 :offset-assert 1232)
|
|
(lightning-timer uint64 :offset-assert 1240)
|
|
(lightning-sound uint32 :offset-assert 1248)
|
|
(lightning-sound-playing basic :offset-assert 1252)
|
|
(glows-on basic :offset-assert 1256)
|
|
(spin float :offset-assert 1260)
|
|
(engine-sound uint32 :offset-assert 1264)
|
|
(engine-sound-playing basic :offset-assert 1268)
|
|
(explosion-sound-index int8 :offset-assert 1272)
|
|
(spin-whoosh-timer uint64 :offset-assert 1280)
|
|
(will-hit-errol basic :offset-assert 1288)
|
|
(spark-part basic :offset-assert 1292)
|
|
(spark-part-on basic :offset-assert 1296)
|
|
(spark-timer uint64 :offset-assert 1304)
|
|
)
|
|
:method-count-assert 195
|
|
:size-assert #x520
|
|
:flag-assert #xc304a00520
|
|
(:methods
|
|
(missile-bot-method-194 () none) ;; 194
|
|
)
|
|
(:state-methods
|
|
jump ;; 44
|
|
kicked ;; 191
|
|
knocked ;; 31
|
|
notice ;; 35
|
|
fizzle ;; 190
|
|
hostile ;; 38
|
|
lift-off ;; 192
|
|
die ;; 40
|
|
explode ;; 193
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *missile-bot-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern stunned? function)
|
|
;; (define-extern missile-bot-get-kick-time function)
|
|
;; (define-extern missile-bot-find-dest function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-boss-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-fbme-dust-color* curve-color-fast)
|
|
;; (define-extern *range-fbme-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-fbme-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-fbme-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-fbme-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-fbme-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-fbme-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fac-boss-missile-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-fbme-color* curve-color-fast)
|
|
;; (define-extern *range-fbme-alpha* curve2d-fast)
|
|
;; (define-extern *range-fbme-scale-x* curve2d-fast)
|
|
;; (define-extern *range-fbme-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-fbme-alpha* curve2d-fast)
|
|
;; (define-extern *curve-fbme-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-fbme-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fac-boss-missile-explosion-texture-curve-settings* object)
|
|
;; (define-extern spt-birth-func-part-factory-debris-trails function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nst-eggs-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *nest-eggs-speech-list* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nst-gas ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-nest-cocoon-gas (task-manager)
|
|
((vehicle-handle uint64 :offset-assert 240)
|
|
(poison-cloud-timer uint64 :offset-assert 248)
|
|
(poison-level float :offset-assert 256)
|
|
(played-damus-talkbox? basic :offset-assert 260)
|
|
(minimap connection-minimap :offset-assert 264)
|
|
(complain-time uint64 :offset-assert 272)
|
|
(played-gas-warning basic :offset-assert 280)
|
|
(part basic :offset-assert 284)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x120
|
|
:flag-assert #x2100a00120
|
|
(:state-methods
|
|
active ;; 15
|
|
paused ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *nest-poison-center* object)
|
|
;; (define-extern *garage-center* object)
|
|
;; (define-extern set-nst-poison! function)
|
|
;; (define-extern birth-func-set-fog-num function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; nst-tasks ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-nest-cocoons (task-manager)
|
|
((vehicle-handle uint64 :offset-assert 236)
|
|
(cocoon-manager-entity basic :offset-assert 244)
|
|
(cocoon-count int32 :offset-assert 248)
|
|
(kill-cocoon-speech int32 :offset-assert 252)
|
|
(minimap connection-minimap :offset-assert 256)
|
|
(actor-group uint32 :offset-assert 260)
|
|
(actor-group-count int32 :offset-assert 264)
|
|
(tunnel basic :offset-assert 268)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x114
|
|
:flag-assert #x2400a00114
|
|
(:methods
|
|
(task-manager-nest-cocoons-method-32 () none) ;; 32
|
|
(task-manager-nest-cocoons-method-33 () none) ;; 33
|
|
(task-manager-nest-cocoons-method-34 () none) ;; 34
|
|
(task-manager-nest-cocoons-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
resolution ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern setup-scorpion function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-marauder ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-marauder (wcar-base)
|
|
((jmod-axles UNKNOWN 4 :offset-assert 2752)
|
|
(jmod-gun-x joint-mod-rotate-local :inline :offset-assert 2880)
|
|
(jmod-gun-y joint-mod-rotate-local :inline :offset-assert 2912)
|
|
(jmod-hatch joint-mod-rotate-local :inline :offset-assert 2944)
|
|
(turret-control turret-control :inline :offset-assert 2976)
|
|
(inaccuracy-factor float :offset-assert 3072)
|
|
(sub-state-time uint32 :offset-assert 3076)
|
|
(sub-state int8 :offset-assert 3080)
|
|
)
|
|
:method-count-assert 204
|
|
:size-assert #xc09
|
|
:flag-assert #xcc0b900c09
|
|
(:methods
|
|
(v-marauder-method-203 () none) ;; 203
|
|
)
|
|
(:state-methods
|
|
explode ;; 60
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *v-marauder-turret-control-info* object)
|
|
;; (define-extern *v-marauder-turret-guard-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desertd-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *desertd-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyfarm-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype farm-marrow (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype farm-beetree (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype farm-cabbage (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype farm-small-cabbage (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype farm-chilirots (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype farm-sprinkler-barrels (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern check-farm-piece-ground function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
;; (define-extern farm-activate function) ;; (function level none)
|
|
;; (define-extern birth-func-ctyfarma-drip function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern check-drop-level-ctyfarma-drop-userdata function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
;; (define-extern birth-func-ctyfarmb-drip function) ;; (function int sparticle-cpuinfo sparticle-launchinfo none)
|
|
;; (define-extern check-drop-level-ctyfarmb-drop-userdata function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyfarma-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyfarmb-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; h-warf ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype h-warf (hvehicle)
|
|
((minalt float :offset-assert 944)
|
|
(curalt float :offset-assert 948)
|
|
(maxalt float :offset-assert 952)
|
|
(forward vector :inline :offset-assert 960)
|
|
(langvel vector :inline :offset-assert 976)
|
|
(rollerr float :offset-assert 992)
|
|
(pitcherr float :offset-assert 996)
|
|
(straighterr float :offset-assert 1000)
|
|
(alterr float :offset-assert 1004)
|
|
(rolling basic :offset-assert 1008)
|
|
(speed float :offset-assert 1012)
|
|
(poierr float :offset-assert 1016)
|
|
(poipos float :offset-assert 1020)
|
|
(poivel float :offset-assert 1024)
|
|
(bigshotcount int8 :offset-assert 1028)
|
|
(deathspin basic :offset-assert 1032)
|
|
(deathrot vector :inline :offset-assert 1040)
|
|
(birth uint64 :offset-assert 1056)
|
|
(stop-time uint64 :offset-assert 1064)
|
|
(bounce-state? basic :offset-assert 1072)
|
|
(bounce-angle float :offset-assert 1076)
|
|
(fire-time UNKNOWN 4 :offset-assert 1080)
|
|
(l1-fire-time uint64 :offset-assert 1112)
|
|
(l1-recharge-time uint64 :offset-assert 1120)
|
|
(snd-cmd-time uint64 :offset-assert 1128)
|
|
(damage-loop uint32 :offset-assert 1136)
|
|
(damage-loop-playing? basic :offset-assert 1140)
|
|
(damage-loop-index uint8 :offset-assert 1144)
|
|
(engine-sound uint32 :offset-assert 1148)
|
|
(engine-boost-sound uint32 :offset-assert 1152)
|
|
(wind-noise-sound uint32 :offset-assert 1156)
|
|
(wind-noise-playing? basic :offset-assert 1160)
|
|
(track-obj uint64 :offset-assert 1168)
|
|
(track-joint int8 :offset-assert 1176)
|
|
(wind float :offset-assert 1180)
|
|
)
|
|
:method-count-assert 165
|
|
:size-assert #x4a0
|
|
:flag-assert #xa5042004a0
|
|
(:methods
|
|
(h-warf-method-162 () none) ;; 162
|
|
(h-warf-method-163 () none) ;; 163
|
|
(h-warf-method-164 () none) ;; 164
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype warf-asc (structure)
|
|
((asc float :offset-assert 0)
|
|
(des float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *h-warf-center-of-level* object)
|
|
;; (define-extern *h-warf-constants* object)
|
|
;; (define-extern impact-reduction function)
|
|
;; (define-extern steer-attenuation function)
|
|
;; (define-extern ascention-atten! function)
|
|
;; (define-extern world-to-local-vec! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; comb-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-factoryd ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *factoryd-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype factory-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(blink0 float :offset-assert 8)
|
|
(blink1 float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factoryd-states (structure)
|
|
((electricity electricity-state :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-factory function)
|
|
;; (define-extern update-mood-factoryd function)
|
|
;; (define-extern set-factoryd-light! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; destroy-dark-eco ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-eco-egg (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lightning-bolt-tower (lightning-bolt)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #x74
|
|
:flag-assert #x1700000074
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tower-lightning-disc (structure)
|
|
((bolt basic :offset-assert 0)
|
|
(orient quaternion :inline :offset-assert 16)
|
|
(cur-state basic :offset-assert 32)
|
|
(last-spawn-time uint64 :offset-assert 40)
|
|
(pts UNKNOWN 8 :offset-assert 48)
|
|
(last-rot-angle float :offset-assert 176)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xb4
|
|
:flag-assert #x9000000b4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dark-eco-orb (process-focusable)
|
|
((last-attack-id uint32 :offset-assert 208)
|
|
(hit-points float :offset-assert 212)
|
|
(alt-actor basic :offset-assert 216)
|
|
(movie? basic :offset-assert 220)
|
|
(minimap connection-minimap :offset-assert 224)
|
|
(discs UNKNOWN 2 :offset-assert 240)
|
|
(shock-sound uint32 :offset-assert 624)
|
|
(plasma-sound uint32 :offset-assert 628)
|
|
(shock-spawn-time uint64 :offset-assert 632)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x280
|
|
:flag-assert #x2002000280
|
|
(:state-methods
|
|
die-movie ;; 31
|
|
die ;; 30
|
|
active ;; 28
|
|
hit ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dark-eco-tower (process-drawable)
|
|
((puffer? basic :offset-assert 200)
|
|
(puffer-h uint64 :offset-assert 208)
|
|
(jump-y float :offset-assert 216)
|
|
(jump-z float :offset-assert 220)
|
|
(creak-sound basic :offset-assert 224)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xe4
|
|
:flag-assert #x15007000e4
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tower-wave (structure)
|
|
((start float :offset-assert 0)
|
|
(end float :offset-assert 4)
|
|
(freq float :offset-assert 8)
|
|
(amp float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-destroy-darkeco (task-manager)
|
|
((actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(handles UNKNOWN 64 :offset-assert 244)
|
|
(orb-handles UNKNOWN 8 :offset-assert 756)
|
|
(orb-status UNKNOWN 8 :offset-assert 820)
|
|
(counter uint32 :offset-assert 852)
|
|
(initial-orb uint64 :offset-assert 860)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x368
|
|
:flag-assert #x2002f00368
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-dark-punch-training (task-manager)
|
|
((gui-id uint32 :offset-assert 240)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xf4
|
|
:flag-assert #x21008000f4
|
|
(:methods
|
|
(task-manager-dark-punch-training-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype grind-electricity (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *initial-orb-pos* object)
|
|
;; (define-extern dark-eco-orb-event-handler function)
|
|
;; (define-extern spawn-shock-effect function)
|
|
;; (define-extern *dark-lightning-width* curve2d-fast)
|
|
;; (define-extern *dark-tower-lightning* object)
|
|
;; (define-extern dark-eco-orb-init-by-other function)
|
|
;; (define-extern dark-eco-orb-init-by-other-pos-scale function)
|
|
;; (define-extern *dark-eco-tower-waves* array)
|
|
;; (define-extern dark-eco-tower-callback function)
|
|
;; (define-extern dark-eco-tower-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factoryc-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-factory-assault (task-manager)
|
|
((explode-car-time uint64 :offset-assert 240)
|
|
(daxter-done basic :offset-assert 248)
|
|
(region-hack basic :offset-assert 252)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x100
|
|
:flag-assert #x2000800100
|
|
)
|
|
|#
|
|
|
|
;; (define-extern factoryd-activate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; was-squad-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype was-squad-control (squad-control)
|
|
((manager uint64 :offset-assert 816)
|
|
(target-count int8 :offset-assert 824)
|
|
(process-count int8 :offset-assert 825)
|
|
(active-count int8 :offset-assert 826)
|
|
(reserve-count int16 :offset-assert 828)
|
|
(spawnable-time uint32 :offset-assert 832)
|
|
(spawn-time uint32 :offset-assert 836)
|
|
(spawn-delay uint32 :offset-assert 840)
|
|
(min-spawn-delay uint32 :offset-assert 844)
|
|
(max-spawn-delay uint32 :offset-assert 848)
|
|
(inaccuracy-factor float :offset-assert 852)
|
|
(attack-delay-factor float :offset-assert 856)
|
|
(target-speed float :offset-assert 860)
|
|
(nav-mesh basic :offset-assert 864)
|
|
(units UNKNOWN 10 :offset-assert 872)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x3b8
|
|
:flag-assert #x25000003b8
|
|
(:methods
|
|
(was-squad-control-method-34 () none) ;; 34
|
|
(was-squad-control-method-35 () none) ;; 35
|
|
(was-squad-control-method-36 () none) ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype was-squad-manager (process)
|
|
((squad basic :offset-assert 128)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x84
|
|
:flag-assert #x1100100084
|
|
(:methods
|
|
(was-squad-manager-method-15 () none) ;; 15
|
|
(was-squad-manager-method-16 () none) ;; 16
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *was-squad-control* was-squad-control)
|
|
;; (define-extern *was-squad-manager* object)
|
|
;; (define-extern was-squad-manager-event-handler function)
|
|
;; (define-extern was-squad-manager-init-by-other function)
|
|
;; (define-extern was-squad-manager-start function)
|
|
;; (define-extern was-squad-manager-kill function)
|
|
;; (define-extern wvh function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wvehicle-sound-loop-state (structure)
|
|
((id uint32 :offset-assert 0)
|
|
(vol float :offset-assert 4)
|
|
(pitch float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-wheel-surface (structure)
|
|
((flags vehicle-wheel-surface-flag :offset-assert 0)
|
|
(surface-type uint8 :offset-assert 1)
|
|
(friction float :offset-assert 4)
|
|
(drag float :offset-assert 8)
|
|
(depth float :offset-assert 12)
|
|
(damage float :offset-assert 16)
|
|
(tire-roll-mix UNKNOWN 4 :offset-assert 20)
|
|
(tire-roll-hum float :offset-assert 20)
|
|
(tire-roll-dirt float :offset-assert 24)
|
|
(tire-roll-sand float :offset-assert 28)
|
|
(tire-roll-knobby float :offset-assert 32)
|
|
(tire-slide-mix UNKNOWN 2 :offset-assert 36)
|
|
(tire-slide-road float :offset-assert 36)
|
|
(tire-slide-dirt float :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
;; field vehicle-wheel-surface-flag is likely a value type.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vehicle-wheel-state (structure)
|
|
((info vehicle-wheel-info :offset-assert 0)
|
|
(flags uint8 :offset-assert 4)
|
|
(prev-flags uint8 :offset-assert 5)
|
|
(handle uint64 :offset-assert 8)
|
|
(probe-local-pos vector :inline :offset-assert 16)
|
|
(probe-local-dir vector :inline :offset-assert 32)
|
|
(local-axis vector :inline :offset-assert 48)
|
|
(surface-pos vector :inline :offset-assert 64)
|
|
(ground-pos vector :inline :offset-assert 80)
|
|
(ground-normal vector :inline :offset-assert 96)
|
|
(trans vector :inline :offset-assert 112)
|
|
(quat quaternion :inline :offset-assert 128)
|
|
(trail-pos UNKNOWN 2 :offset-assert 144)
|
|
(surface vehicle-wheel-surface :offset-assert 176)
|
|
(pos float :offset-assert 180)
|
|
(pos2 float :offset-assert 184)
|
|
(inertia float :offset-assert 188)
|
|
(steer-angle float :offset-assert 192)
|
|
(angle float :offset-assert 196)
|
|
(rev float :offset-assert 200)
|
|
(x-scale float :offset-assert 204)
|
|
(torque float :offset-assert 208)
|
|
(braking-torque float :offset-assert 212)
|
|
(up-force float :offset-assert 216)
|
|
(drive-diff float :offset-assert 220)
|
|
(side-vel float :offset-assert 224)
|
|
(up-vel float :offset-assert 228)
|
|
(forward-vel float :offset-assert 232)
|
|
(forward-slip-vel float :offset-assert 236)
|
|
(friction-coef float :offset-assert 240)
|
|
(sink-depth float :offset-assert 244)
|
|
(sin-susp-ang float :offset-assert 248)
|
|
(cos-susp-ang float :offset-assert 252)
|
|
(part-birth-accum UNKNOWN 4 :offset-assert 256)
|
|
(tread-time uint32 :offset-assert 272)
|
|
(tread-tracker uint64 :offset-assert 280)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x120
|
|
:flag-assert #x900000120
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wvehicle-probe-work (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(local-normal vector :inline :offset-assert 16)
|
|
(world-pos vector :inline :offset-assert 32)
|
|
(world-normal vector :inline :offset-assert 48)
|
|
(wheel-axis vector :inline :offset-assert 64)
|
|
(side-dir vector :inline :offset-assert 80)
|
|
(forward-dir vector :inline :offset-assert 96)
|
|
(velocity vector :inline :offset-assert 112)
|
|
(probe-uu float :offset-assert 128)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x84
|
|
:flag-assert #x900000084
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wvehicle-physics-work (structure)
|
|
((mat matrix :inline :offset-assert 0)
|
|
(force vector :inline :offset-assert 64)
|
|
(velocity vector :inline :offset-assert 80)
|
|
(world-pos vector :inline :offset-assert 96)
|
|
(world-normal vector :inline :offset-assert 112)
|
|
(local-pos vector :inline :offset-assert 128)
|
|
(steering-axis vector :inline :offset-assert 144)
|
|
(probe-dir vector :inline :offset-assert 160)
|
|
(tmp vector :inline :offset-assert 176)
|
|
(p-body vector :inline :offset-assert 192)
|
|
(axis vector :inline :offset-assert 208)
|
|
(dir vector :inline :offset-assert 224)
|
|
(ground-normal-sum vector :inline :offset-assert 240)
|
|
(ground-pos vector :inline :offset-assert 256)
|
|
(forward-dir vector :inline :offset-assert 272)
|
|
(side-dir vector :inline :offset-assert 288)
|
|
(wheel-axis vector :inline :offset-assert 304)
|
|
(wsphere sphere :inline :offset-assert 320)
|
|
(friction-coef float :offset-assert 336)
|
|
(wheel-radius float :offset-assert 340)
|
|
(side-force float :offset-assert 344)
|
|
(forward-force float :offset-assert 348)
|
|
(max-forward-tire-grip float :offset-assert 352)
|
|
(max-side-tire-grip float :offset-assert 356)
|
|
(inertia-eff float :offset-assert 360)
|
|
(ground-torque float :offset-assert 364)
|
|
(braking-torque float :offset-assert 368)
|
|
(total-torque float :offset-assert 372)
|
|
(limit-braking-torque float :offset-assert 376)
|
|
(max-braking-torque float :offset-assert 380)
|
|
(surface-drag float :offset-assert 384)
|
|
(water-y float :offset-assert 388)
|
|
(cur-time uint32 :offset-assert 392)
|
|
(surface-type uint8 :offset-assert 396)
|
|
(surface-depth float :offset-assert 400)
|
|
(material uint64 :offset-assert 408)
|
|
(probe-work-array UNKNOWN 4 :offset-assert 416)
|
|
(cquery collide-query :inline :offset-assert 992)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5fc
|
|
:flag-assert #x9000005fc
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wvehicle (vehicle)
|
|
((race race-control :inline :offset-assert 704)
|
|
(target-status squad-target-status :inline :offset-assert 800)
|
|
(ai-controls vehicle-controls :inline :offset-assert 868)
|
|
(minimap connection-minimap :offset-assert 892)
|
|
(net basic :offset-assert 896)
|
|
(engine-rev float :offset-assert 900)
|
|
(engine-inertia float :offset-assert 904)
|
|
(engine-torque float :offset-assert 908)
|
|
(engine-max-torque float :offset-assert 912)
|
|
(engine-rpm float :offset-assert 916)
|
|
(sound-engine-rpm float :offset-assert 920)
|
|
(wheel-rev float :offset-assert 924)
|
|
(wheel-inertia float :offset-assert 928)
|
|
(wheel-torque float :offset-assert 932)
|
|
(wheel-braking-torque float :offset-assert 936)
|
|
(wheel-ground-torque float :offset-assert 940)
|
|
(clutch-grab float :offset-assert 944)
|
|
(gear-ratio float :offset-assert 948)
|
|
(final-drive-ratio float :offset-assert 952)
|
|
(total-gear-ratio float :offset-assert 956)
|
|
(inv-total-gear-ratio float :offset-assert 960)
|
|
(avg-drive-wheel-radius float :offset-assert 964)
|
|
(drive-wheel-inertia float :offset-assert 968)
|
|
(clutch-inertia float :offset-assert 972)
|
|
(idle-throttle float :offset-assert 976)
|
|
(susp-spring-control float :offset-assert 980)
|
|
(jump-control float :offset-assert 984)
|
|
(ai-min-speed float :offset-assert 988)
|
|
(ai-max-speed float :offset-assert 992)
|
|
(shortcut-speed-factor float :offset-assert 996)
|
|
(path-deviation float :offset-assert 1000)
|
|
(turbo-supply float :offset-assert 1004)
|
|
(turbo-ready float :offset-assert 1008)
|
|
(ai-state uint8 :offset-assert 1012)
|
|
(return-ai-state uint8 :offset-assert 1013)
|
|
(i-barrel int8 :offset-assert 1014)
|
|
(shift-state uint8 :offset-assert 1015)
|
|
(gear-select int8 :offset-assert 1016)
|
|
(next-gear-select int8 :offset-assert 1017)
|
|
(shift-time uint32 :offset-assert 1020)
|
|
(impact rigid-body-impact :inline :offset-assert 1024)
|
|
(wheel UNKNOWN 4 :offset-assert 1088)
|
|
(gravity-dir vector :inline :offset-assert 2240)
|
|
(ai-target-point vector :inline :offset-assert 2256)
|
|
(surface-velocity vector :inline :offset-assert 2272)
|
|
(turret-local-pos vector :inline :offset-assert 2288)
|
|
(gun-local-pos vector :inline :offset-assert 2304)
|
|
(gun-local-dir vector :inline :offset-assert 2320)
|
|
(gun-aim-yaw float :offset-assert 2336)
|
|
(gun-aim-yaw-vel float :offset-assert 2340)
|
|
(gun-targ-yaw float :offset-assert 2344)
|
|
(gun-targ-pitch float :offset-assert 2348)
|
|
(gun-yaw float :offset-assert 2352)
|
|
(gun-pitch float :offset-assert 2356)
|
|
(gun-yaw-vel float :offset-assert 2360)
|
|
(gun-pitch-vel float :offset-assert 2364)
|
|
(gun-kick float :offset-assert 2368)
|
|
(lock-turret basic :offset-assert 2372)
|
|
(tire-roll-loop-state UNKNOWN 4 :offset-assert 2376)
|
|
(tire-slide-loop-state UNKNOWN 2 :offset-assert 2440)
|
|
(engine1-sound-id uint32 :offset-assert 2472)
|
|
(engine2-sound-id uint32 :offset-assert 2476)
|
|
(engine3-sound-id uint32 :offset-assert 2480)
|
|
(damage-sound-id uint32 :offset-assert 2484)
|
|
(water-sound-id uint32 :offset-assert 2488)
|
|
(turbo-sound-id uint32 :offset-assert 2492)
|
|
(shortcut-time uint32 :offset-assert 2496)
|
|
(overturned-time uint32 :offset-assert 2500)
|
|
(splash-time uint32 :offset-assert 2504)
|
|
(knobby-time uint32 :offset-assert 2508)
|
|
(susp-creak-time uint32 :offset-assert 2512)
|
|
(shoot-time uint32 :offset-assert 2516)
|
|
(shoot-delay uint32 :offset-assert 2520)
|
|
(jump-time uint32 :offset-assert 2524)
|
|
(ground-time uint32 :offset-assert 2528)
|
|
(ram-time uint32 :offset-assert 2532)
|
|
(attached-array UNKNOWN 16 :offset-assert 2536)
|
|
(eng1-vol float :offset-assert 2664)
|
|
(eng2-vol float :offset-assert 2668)
|
|
(eng3-vol float :offset-assert 2672)
|
|
(eng-pitch-variance float :offset-assert 2676)
|
|
(eng-pitch-variance-seek float :offset-assert 2680)
|
|
(eng-vol-variance float :offset-assert 2684)
|
|
(eng-vol-variance-seek float :offset-assert 2688)
|
|
(eng-pitch-offset float :offset-assert 2692)
|
|
(eng-flutter-envelope float :offset-assert 2696)
|
|
(water-sound-envelope float :offset-assert 2700)
|
|
(other-proc uint64 :offset-assert 2704)
|
|
(other-pos vector :inline :offset-assert 2720)
|
|
)
|
|
:method-count-assert 203
|
|
:size-assert #xab0
|
|
:flag-assert #xcb0a300ab0
|
|
(:methods
|
|
(wvehicle-method-152 () none) ;; 152
|
|
(wvehicle-method-153 () none) ;; 153
|
|
(wvehicle-method-154 () none) ;; 154
|
|
(wvehicle-method-155 () none) ;; 155
|
|
(wvehicle-method-156 () none) ;; 156
|
|
(wvehicle-method-157 () none) ;; 157
|
|
(wvehicle-method-158 () none) ;; 158
|
|
(wvehicle-method-159 () none) ;; 159
|
|
(wvehicle-method-160 () none) ;; 160
|
|
(wvehicle-method-161 () none) ;; 161
|
|
(wvehicle-method-162 () none) ;; 162
|
|
(wvehicle-method-163 () none) ;; 163
|
|
(wvehicle-method-164 () none) ;; 164
|
|
(wvehicle-method-165 () none) ;; 165
|
|
(wvehicle-method-166 () none) ;; 166
|
|
(wvehicle-method-167 () none) ;; 167
|
|
(wvehicle-method-168 () none) ;; 168
|
|
(wvehicle-method-169 () none) ;; 169
|
|
(wvehicle-method-170 () none) ;; 170
|
|
(wvehicle-method-171 () none) ;; 171
|
|
(wvehicle-method-172 () none) ;; 172
|
|
(wvehicle-method-173 () none) ;; 173
|
|
(wvehicle-method-174 () none) ;; 174
|
|
(wvehicle-method-175 () none) ;; 175
|
|
(wvehicle-method-176 () none) ;; 176
|
|
(wvehicle-method-177 () none) ;; 177
|
|
(wvehicle-method-178 () none) ;; 178
|
|
(wvehicle-method-179 () none) ;; 179
|
|
(wvehicle-method-180 () none) ;; 180
|
|
(wvehicle-method-181 () none) ;; 181
|
|
(wvehicle-method-182 () none) ;; 182
|
|
(wvehicle-method-183 () none) ;; 183
|
|
(wvehicle-method-184 () none) ;; 184
|
|
(wvehicle-method-185 () none) ;; 185
|
|
(wvehicle-method-186 () none) ;; 186
|
|
(wvehicle-method-187 () none) ;; 187
|
|
(wvehicle-method-188 () none) ;; 188
|
|
(wvehicle-method-189 () none) ;; 189
|
|
(wvehicle-method-190 () none) ;; 190
|
|
(wvehicle-method-191 () none) ;; 191
|
|
(wvehicle-method-192 () none) ;; 192
|
|
(wvehicle-method-193 () none) ;; 193
|
|
(wvehicle-method-194 () none) ;; 194
|
|
(wvehicle-method-195 () none) ;; 195
|
|
(wvehicle-method-196 () none) ;; 196
|
|
(wvehicle-method-197 () none) ;; 197
|
|
(wvehicle-method-198 () none) ;; 198
|
|
(wvehicle-method-199 () none) ;; 199
|
|
(wvehicle-method-200 () none) ;; 200
|
|
(wvehicle-method-201 () none) ;; 201
|
|
(wvehicle-method-202 () none) ;; 202
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wvehicle-ai-drop-off-params (structure)
|
|
((dest vector :inline :offset-assert 0)
|
|
(proc basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
;; (define-extern rpm->radians-per-sec function)
|
|
;; (define-extern radians-per-sec->rpm function)
|
|
;; (define-extern wvehicle-surface-type-from-material function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern sparticle-motion-blur-dirt function)
|
|
;; (define-extern spt-birth-func-brightness-buggy-rocks function)
|
|
;; (define-extern spt-birth-func-part-buggy-rocks function)
|
|
;; (define-extern spt-birth-func-part-dbuggy-debris function)
|
|
;; (define-extern *range-wv-wsplash-color* curve-color-fast)
|
|
;; (define-extern *range-wv-wsplash-alpha* curve2d-fast)
|
|
;; (define-extern *range-wv-wsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-wv-wsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-wv-wsplash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-wv-wsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-wv-wsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-wv-water-splash-curve-settings* object)
|
|
;; (define-extern *range-wv-splash-color* curve-color-fast)
|
|
;; (define-extern *range-wv-splash-alpha* curve2d-fast)
|
|
;; (define-extern *range-wv-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-wv-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-wv-splash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-wv-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-wv-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-wv-water-splash-center-curve-settings* object)
|
|
;; (define-extern check-scorp-shell-level1 function)
|
|
;; (define-extern check-scorp-shell-level2 function)
|
|
;; (define-extern *curve-toad-linear-up-red* object)
|
|
;; (define-extern *trail-color-curve-toad-grenade* curve-color-fast)
|
|
;; (define-extern *curve-grenade-linear-toad-trail* curve2d-fast)
|
|
;; (define-extern *toad-grenade-trail* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vinroom-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype turbo-pickup (process-drawable)
|
|
((available symbol :offset-assert 200) ;; guessed by decompiler
|
|
(persistent basic :offset-assert 204)
|
|
(birth-time uint64 :offset-assert 208)
|
|
(collector uint64 :offset-assert 216)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xe0
|
|
:flag-assert #x17006000e0
|
|
(:methods
|
|
(turbo-pickup-method-22 () none) ;; 22 ;; (find-ground (_type_) symbol 22)
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
die ;; 21, old: (die () _type_ :state 21)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern turbo-pickup-init-by-other function) ;; (function vector none :behavior turbo-pickup)
|
|
;; (define-extern race-turbo-pickup-spawn function)
|
|
;; (define-extern turbo-pickup-spawn function) ;; (function process vector turbo-pickup :behavior turbo-pickup)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ltnfxhip-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ltnfxhip-texture-anim-array* texture-anim-array)
|
|
;; (define-extern ltnfxhip-texture-anim-func function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-physics ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *wvehicle-surfaces* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wlander-male ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wlander (civilian)
|
|
((mad-level float :offset-assert 1128)
|
|
(los los-control :inline :offset-assert 1136)
|
|
(target-pos vector :inline :offset-assert 1312)
|
|
(gun-joint int32 :offset-assert 1328)
|
|
(gun-axis int32 :offset-assert 1332)
|
|
(gun-length float :offset-assert 1336)
|
|
(shoot-time uint64 :offset-assert 1344)
|
|
(last-time-far uint64 :offset-assert 1352)
|
|
(last-time-los uint64 :offset-assert 1360)
|
|
(shot-sound int32 :offset-assert 1368)
|
|
(knocked-collide basic :offset-assert 1372)
|
|
(knocked-speed-scale float :offset-assert 1384)
|
|
(male basic :offset-assert 1388)
|
|
)
|
|
:method-count-assert 243
|
|
:size-assert #x570
|
|
:flag-assert #xf304f00570
|
|
(:methods
|
|
(wlander-method-238 () none) ;; 238
|
|
(wlander-method-239 () none) ;; 239
|
|
(wlander-method-240 () none) ;; 240
|
|
(wlander-method-241 () none) ;; 241
|
|
(wlander-method-242 () none) ;; 242
|
|
)
|
|
(:state-methods
|
|
knocked-recover ;; 32
|
|
knocked ;; 31
|
|
standing ;; 236
|
|
active ;; 34
|
|
gun-shoot ;; 234
|
|
hostile ;; 38
|
|
panic ;; 237
|
|
close-attack ;; 235
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wlander-male (wlander)
|
|
()
|
|
:method-count-assert 243
|
|
:size-assert #x570
|
|
:flag-assert #xf304f00570
|
|
(:state-methods
|
|
gun-shoot ;; 234
|
|
standing ;; 236
|
|
close-attack ;; 235
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wlander-female (wlander)
|
|
((gunout basic :offset-assert 1392)
|
|
)
|
|
:method-count-assert 243
|
|
:size-assert #x574
|
|
:flag-assert #xf305000574
|
|
(:state-methods
|
|
wait ;; 190
|
|
close-attack ;; 235
|
|
gun-shoot ;; 234
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern wlander-travel-anim function)
|
|
;; (define-extern *wlander-male-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern wlander-male-joint-callback function)
|
|
;; (define-extern *wlander-female-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern wlander-female-joint-callback function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wvehicle-hud ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-vehicle-turbo (hud)
|
|
((tex-rim basic :offset-assert 2756)
|
|
(tex-on basic :offset-assert 2760)
|
|
(tex-off basic :offset-assert 2764)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xad0
|
|
:flag-assert #x1b0a500ad0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern hud-vehicle-turbo-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flitter ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flitter (nav-enemy)
|
|
((move-angle float :offset-assert 620)
|
|
(heading basic :offset-assert 624)
|
|
(change-dir-time uint64 :offset-assert 632) ;; time-frame
|
|
(last-change-dir uint64 :offset-assert 640)
|
|
(off-screen-timer uint64 :offset-assert 648)
|
|
(amb-sound-timer uint64 :offset-assert 656)
|
|
(attack-time uint64 :offset-assert 664) ;; time-frame
|
|
(target-pos vector :inline :offset-assert 672)
|
|
(attack-pos vector :inline :offset-assert 688)
|
|
(base-height float :offset-assert 704)
|
|
(minimap connection-minimap :offset-assert 708)
|
|
)
|
|
:method-count-assert 196
|
|
:size-assert #x2c8
|
|
:flag-assert #xc4025002c8
|
|
(:methods
|
|
(flitter-method-192 () none) ;; 192
|
|
(flitter-method-193 () none) ;; 193
|
|
(flitter-method-194 () none) ;; 194
|
|
(flitter-method-195 () none) ;; 195
|
|
)
|
|
(:state-methods
|
|
ambush-jumping ;; 191
|
|
ambush ;; 47
|
|
active ;; 34
|
|
circling ;; 157
|
|
stare ;; 37
|
|
attack ;; 190
|
|
hostile ;; 38
|
|
die ;; 40
|
|
victory ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern check-drop-level-flitter-dirt-rubble function) ;; (function sparticle-system sparticle-cpuinfo vector none)
|
|
;; (define-extern *flitter-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern flitter-fall-and-play-death-anim function) ;; (function art-joint-anim float time-frame none :behavior flitter)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; comb-field ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype comb-field (process-drawable)
|
|
((pass int32 :offset-assert 200)
|
|
(incoming-attack-id uint32 :offset-assert 204)
|
|
(next-message-time uint64 :offset-assert 208)
|
|
(message int32 :offset-assert 216)
|
|
(plane plane :inline :offset-assert 224)
|
|
(color vector :inline :offset-assert 240)
|
|
(target-pos vector :inline :offset-assert 256)
|
|
(hum-sound-id uint32 :offset-assert 272)
|
|
(flash float :offset-assert 276)
|
|
(touch-count int32 :offset-assert 280)
|
|
(touch-time uint64 :offset-assert 288)
|
|
(breach basic :offset-assert 296)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x12c
|
|
:flag-assert #x1800b0012c
|
|
(:methods
|
|
(comb-field-method-21 () none) ;; 21
|
|
(comb-field-method-22 () none) ;; 22
|
|
(comb-field-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle-close ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-projectiles ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-scorp-shot (projectile)
|
|
((init-pos vector :inline :offset-assert 512)
|
|
(init-dir vector :inline :offset-assert 528)
|
|
(collide-normal vector :inline :offset-assert 544)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x230
|
|
:flag-assert #x2901b00230
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype v-snake-shot (v-scorp-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x230
|
|
:flag-assert #x2901b00230
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype v-rhino-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype v-toad-shot (projectile)
|
|
((trail-tracker uint64 :offset-assert 512)
|
|
(blast-radius float :offset-assert 520)
|
|
)
|
|
:method-count-assert 42
|
|
:size-assert #x20c
|
|
:flag-assert #x2a0190020c
|
|
(:methods
|
|
(v-toad-shot-method-41 () none) ;; 41
|
|
)
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype v-marauder-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
;; (define-extern v-scorp-shot-move function)
|
|
;; (define-extern cshape-reaction-scorp-shot function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wcar-base (wvehicle)
|
|
((rider-hand-joint-array UNKNOWN 2 :offset-assert 2736)
|
|
)
|
|
:method-count-assert 203
|
|
:size-assert #xab2
|
|
:flag-assert #xcb0a400ab2
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wcar-snake-base (wcar-base)
|
|
((local-gun-pos UNKNOWN 2 :offset-assert 2752)
|
|
(jmod-axles UNKNOWN 4 :offset-assert 2784)
|
|
(jmod-shock-tops UNKNOWN 4 :offset-assert 2912)
|
|
(jmod-shock-mids UNKNOWN 4 :offset-assert 3040)
|
|
(jmod-guns UNKNOWN 2 :offset-assert 3296)
|
|
)
|
|
:method-count-assert 203
|
|
:size-assert #xd60
|
|
:flag-assert #xcb0ce00d60
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *v-turtle-constants* object)
|
|
;; (define-extern *v-snake-constants* object)
|
|
;; (define-extern *v-scorpion-constants* object)
|
|
;; (define-extern *v-toad-constants* object)
|
|
;; (define-extern *v-fox-constants* object)
|
|
;; (define-extern *v-rhino-constants* object)
|
|
;; (define-extern *v-mirage-constants* object)
|
|
;; (define-extern *v-x-ride-constants* object)
|
|
;; (define-extern *v-marauder-constants* object)
|
|
;; (define-extern *v-faccar-constants* object)
|
|
;; (define-extern *v-catapult-constants* object)
|
|
;; (define-extern *wcar-explosion-info* vehicle-explosion-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-turtle ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-turtle (wcar-base)
|
|
((jmod-axles UNKNOWN 4 :offset-assert 2752)
|
|
(jmod-shock-tops UNKNOWN 4 :offset-assert 2880)
|
|
(jmod-shock-mids UNKNOWN 4 :offset-assert 3008)
|
|
(jmod-antenna UNKNOWN 4 :offset-assert 3264)
|
|
(ant-tip-vel vector :inline :offset-assert 3392)
|
|
(spring-pos vector :inline :offset-assert 3408)
|
|
(spring-vel vector :inline :offset-assert 3424)
|
|
)
|
|
:method-count-assert 203
|
|
:size-assert #xd70
|
|
:flag-assert #xcb0cf00d70
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; minee-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype minee-elevator (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; stadiuma-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype stadiumb-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype stadiuma-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(electricity UNKNOWN 2 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-stadiumb function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern init-mood-stadiuma function)
|
|
;; (define-extern update-mood-stadiuma function)
|
|
;; (define-extern set-stadiuma-electricity-scale! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-snake ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-snake (wcar-snake-base)
|
|
()
|
|
:method-count-assert 203
|
|
:size-assert #xd60
|
|
:flag-assert #xcb0ce00d60
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ash ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ashelin-anim-info (structure)
|
|
((anim-index int32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ashelin-global-info (basic)
|
|
((prev-blue-hit int8 :offset-assert 4)
|
|
(blue-hit-anim int32 6 :offset-assert 8) ;; guessed by decompiler
|
|
(blue-hit-land-anim int32 6 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ashelin-global-info* ashelin-global-info) ;; ashelin-global-info
|
|
;; (define-extern *ashelin-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-toad ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-toad (wcar-base)
|
|
((jmod-axles UNKNOWN 4 :offset-assert 2752)
|
|
(jmod-shock-tops UNKNOWN 2 :offset-assert 2880)
|
|
(jmod-shock-bots UNKNOWN 2 :offset-assert 2944)
|
|
)
|
|
:method-count-assert 204
|
|
:size-assert #xc00
|
|
:flag-assert #xcc0b800c00
|
|
(:methods
|
|
(v-toad-method-203 () none) ;; 203
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-rhino ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-rhino (wcar-base)
|
|
((jmod-axles UNKNOWN 4 :offset-assert 2752)
|
|
(jmod-gun-kick joint-mod-add-local :inline :offset-assert 2880)
|
|
(jmod-gun-turn joint-mod-rotate-local :inline :offset-assert 2944)
|
|
)
|
|
:method-count-assert 203
|
|
:size-assert #xba0
|
|
:flag-assert #xcb0b200ba0
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; w-parking-spot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype w-parking-spot (process-drawable)
|
|
((vehicle uint64 :offset-assert 200)
|
|
(should-spawn? basic :offset-assert 208)
|
|
(should-cleanup? basic :offset-assert 212)
|
|
(v-type uint8 :offset-assert 216)
|
|
(minimap connection-minimap :offset-assert 220)
|
|
(test-sphere sphere :inline :offset-assert 224)
|
|
(arrow uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xf8
|
|
:flag-assert #x1b008000f8
|
|
(:methods
|
|
(w-parking-spot-method-21 () none) ;; 21
|
|
(w-parking-spot-method-22 () none) ;; 22
|
|
(w-parking-spot-method-23 () none) ;; 23
|
|
(w-parking-spot-method-24 () none) ;; 24
|
|
(w-parking-spot-method-25 () none) ;; 25
|
|
(w-parking-spot-method-26 () none) ;; 26
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ai-task-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ai-task (basic)
|
|
((next ai-task :offset-assert 4) ;; guessed by decompiler
|
|
(prev ai-task :offset-assert 8) ;; guessed by decompiler
|
|
(pool ai-task-pool :offset-assert 12) ;; guessed by decompiler
|
|
(unique-id uint32 :offset-assert 16)
|
|
(bytes int8 16 :offset-assert 32) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
(:methods
|
|
(ai-task-method-9 () none) ;; 9 ;; (reset-task! (_type_) none 9)
|
|
(ai-task-method-10 () none) ;; 10 ;; (ai-task-method-10 (_type_ bot) none 10)
|
|
(ai-task-method-11 () none) ;; 11 ;; (ai-task-method-11 (_type_ bot) none 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ai-task-pool (basic)
|
|
((anchor ai-task :offset-assert 4) ;; guessed by decompiler
|
|
(tasks (pointer uint32) :offset-assert 8) ;; guessed by decompiler
|
|
(tasks-length uint32 :offset-assert 12)
|
|
(unique-id uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x14
|
|
:flag-assert #xc00000014
|
|
(:methods
|
|
(ai-task-pool-method-9 () none) ;; 9 ;; (assign-ids! (_type_ type) ai-task 9)
|
|
(ai-task-pool-method-10 () none) ;; 10 ;; (set-next-task! (_type_ ai-task) none 10)
|
|
(ai-task-pool-method-11 () none) ;; 11 ;; (ai-task-pool-method-11 (_type_) ai-task 11)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ai-task-control (basic)
|
|
((anchor ai-task :offset-assert 4) ;; guessed by decompiler
|
|
(pool ai-task-pool :offset-assert 8) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #xc
|
|
:flag-assert #x120000000c
|
|
(:methods
|
|
;; (new (symbol type ai-task-pool) _type_ 0)
|
|
(ai-task-control-method-9 () none) ;; 9 ;; (ai-task-control-method-9 (_type_) none 9)
|
|
(ai-task-control-method-10 () none) ;; 10 ;; (ai-task-control-method-10 (_type_ bot) none 10)
|
|
(ai-task-control-method-11 () none) ;; 11 ;; (get-task-by-type (_type_ type bot) ai-task 11)
|
|
(ai-task-control-method-12 () none) ;; 12 ;; (ai-task-control-method-12 (_type_ bot) symbol 12)
|
|
(ai-task-control-method-13 () none) ;; 13 ;; (ai-task-control-method-13 (_type_ ai-task bot) ai-task 13)
|
|
(ai-task-control-method-14 () none) ;; 14 ;; (ai-task-control-method-14 (_type_ ai-task bot) none 14)
|
|
(ai-task-control-method-15 () none) ;; 15 ;; (init-task! (_type_ type bot) ai-task 15)
|
|
(ai-task-control-method-16 () none) ;; 16 ;; (set-next-task-for-pool! (_type_ ai-task) none 16)
|
|
(ai-task-control-method-17 () none) ;; 17 ;; (set-next-task! (_type_ ai-task) none 17)
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ash-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ashelin-course (bot-course)
|
|
((ouch-speeches bot-speech-list-shuffle :offset-assert 48) ;; guessed by decompiler
|
|
(victory-speeches bot-speech-list-shuffle :offset-assert 52) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
;; field default-check-too-far uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype ashelin (bot)
|
|
((knocked-anim art-joint-anim :offset-assert 1008) ;; guessed by decompiler
|
|
(travel-anim-interp float :offset-assert 1012)
|
|
(fired-gun-count uint32 :offset-assert 1016)
|
|
(last-fire-time uint64 :offset-assert 1024) ;; time-frame
|
|
(victory-speech-time uint64 :offset-assert 1032) ;; time-frame
|
|
(frontline plane :inline :offset-assert 1040)
|
|
)
|
|
:method-count-assert 262
|
|
:size-assert #x420
|
|
:flag-assert #x10603a00420
|
|
(:methods
|
|
(ashelin-method-237 () none) ;; 237 ;; (fire-projectile (_type_ vector) none 237)
|
|
(ashelin-method-238 () none) ;; 238 ;; (ashelin-method-238 (_type_ symbol symbol) symbol 238)
|
|
(ashelin-method-239 () none) ;; 239 ;; (ashelin-method-239 (_type_) none 239)
|
|
(ashelin-method-240 () none) ;; 240 ;; (ashelin-method-240 (_type_ int) none 240)
|
|
(ashelin-method-241 () none) ;; 241 ;; (ashelin-method-241 (_type_) int 241)
|
|
(ashelin-method-242 () none) ;; 242 ;; (ashelin-method-242 (_type_) int 242)
|
|
(ashelin-method-243 () none) ;; 243 ;; (ashelin-method-243 (_type_ float) int 243)
|
|
(ashelin-method-244 () none) ;; 244 ;; (ashelin-method-244 (_type_) none 244)
|
|
(ashelin-method-245 () none) ;; 245 ;; (ashelin-method-245 (_type_) none 245)
|
|
(ashelin-method-246 () none) ;; 246 ;; (ashelin-method-246 (_type_) int 246)
|
|
(ashelin-method-247 () none) ;; 247 ;; (ashelin-method-247 (_type_) symbol 247)
|
|
(ashelin-method-248 () none) ;; 248 ;; (ashelin-method-248 (_type_) symbol 248)
|
|
(ashelin-method-249 () none) ;; 249 ;; (ashelin-method-249 (_type_) none 249)
|
|
(ashelin-method-250 () none) ;; 250 ;; (ashelin-method-250 (_type_ symbol) none 250)
|
|
(ashelin-method-251 () none) ;; 251
|
|
(ashelin-method-252 () none) ;; 252
|
|
(ashelin-method-253 () none) ;; 253
|
|
(ashelin-method-254 () none) ;; 254
|
|
(ashelin-method-255 () none) ;; 255
|
|
(ashelin-method-256 () none) ;; 256
|
|
(ashelin-method-257 () none) ;; 257
|
|
(ashelin-method-258 () none) ;; 258
|
|
(ashelin-method-259 () none) ;; 259
|
|
(ashelin-method-260 () none) ;; 260
|
|
(ashelin-method-261 () none) ;; 261
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype asht-wait-spot (ai-task)
|
|
((check-done (function asht-wait-spot ashelin symbol) :offset-assert 32) ;; guessed by decompiler
|
|
(which-spot int8 :offset-assert 36)
|
|
(num-spots uint8 :offset-assert 37)
|
|
(spot-indexes uint8 6 :offset-assert 38) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype asht-fight-focus (ai-task)
|
|
()
|
|
:method-count-assert 12
|
|
:size-assert #x30
|
|
:flag-assert #xc00000030
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ash-shot ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ashelin-shot (projectile)
|
|
((tail-pos vector :inline :offset-assert 512)
|
|
(hit-pos vector :inline :offset-assert 528)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
;; (define-extern ashelin-shot-move function) ;; (function ashelin-shot none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctywide-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *security-texture-anim-array* texture-anim-array) ;; (texture-anim-array texture-anim)
|
|
;; (define-extern set-security-color! function) ;; (function vector vector)
|
|
;; (define-extern set-security-flash! function) ;; (function vector vector)
|
|
;; (define-extern set-security-texture-masks! function) ;; (function vector symbol)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ash-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; marauder ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype marauder (nav-enemy)
|
|
((los los-control :inline :offset-assert 624)
|
|
(target-pos vector :inline :offset-assert 800)
|
|
(jump-attack basic :offset-assert 816)
|
|
(jump-info enemy-jump-info :inline :offset-assert 832)
|
|
(save basic :offset-assert 920)
|
|
(save-pos vector :inline :offset-assert 928)
|
|
(ambush? basic :offset-assert 944)
|
|
(knocked-back? basic :offset-assert 948)
|
|
(run-anim int32 :offset-assert 952)
|
|
(gun? basic :offset-assert 956)
|
|
(target-last-attacker? basic :offset-assert 960)
|
|
(visible-last uint64 :offset-assert 968)
|
|
(traj trajectory :inline :offset-assert 976)
|
|
(skip-jump basic :offset-assert 1016)
|
|
)
|
|
:method-count-assert 199
|
|
:size-assert #x3fc
|
|
:flag-assert #xc7038003fc
|
|
(:methods
|
|
(marauder-method-196 () none) ;; 196
|
|
(marauder-method-197 () none) ;; 197
|
|
(marauder-method-198 () none) ;; 198
|
|
)
|
|
(:state-methods
|
|
save ;; 191
|
|
save-wait ;; 192
|
|
hostile ;; 38
|
|
gun-shoot ;; 194
|
|
jump ;; 44
|
|
jump-out ;; 195
|
|
idle ;; 33
|
|
stare ;; 37
|
|
victory ;; 39
|
|
ambush ;; 47
|
|
attack-run ;; 190
|
|
lava-die ;; 193
|
|
knocked ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype marauder-init-by-other-params (enemy-init-by-other-params)
|
|
((multi-focus basic :offset-assert 48)
|
|
(skip-jump basic :offset-assert 52)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-marauder-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *marauder-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern marauder-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; guard-tazer ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spread-lightning-lazer function) ;; (function lightning-control vector vector vector none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ash-oasis-course ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ashelin-oasis (ashelin)
|
|
((player-in-bounds-time uint64 :offset-assert 1056)
|
|
(last-speech-time uint64 :offset-assert 1064)
|
|
(last-speech-id int32 :offset-assert 1072)
|
|
(last-sound-trans vector :inline :offset-assert 1088)
|
|
(last-sound-id uint32 :offset-assert 1104)
|
|
(minimap connection-minimap :offset-assert 1108)
|
|
)
|
|
:method-count-assert 264
|
|
:size-assert #x458
|
|
:flag-assert #x10803e00458
|
|
(:methods
|
|
(ashelin-oasis-method-262 () none) ;; 262
|
|
(ashelin-oasis-method-263 () none) ;; 263
|
|
)
|
|
(:state-methods
|
|
traveling ;; 241
|
|
knocked ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ash-oasis-course* ashelin-course)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; assault-shared ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype assault-cam-info (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(mat matrix :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x50
|
|
:flag-assert #x900000050
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype triangle-dists (structure)
|
|
((dist0 float :offset-assert 0)
|
|
(dist1 float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-room-collision (structure)
|
|
((cam-matrix matrix :inline :offset-assert 0)
|
|
(cam-pos vector :inline :offset-assert 64)
|
|
(clip-dists triangle-dists :inline :offset-assert 80)
|
|
(hoz-clip-dist float :offset-assert 88)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x5c
|
|
:flag-assert #x90000005c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-room (structure)
|
|
((center-pos vector :inline :offset-assert 0)
|
|
(cam-info assault-cam-info :offset-assert 16)
|
|
(collision assault-room-collision :offset-assert 20)
|
|
(node-positions basic :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1c
|
|
:flag-assert #x90000001c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-speech-instance (speech-instance)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *assault-speech-list* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyindb-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ctyindb-steam-b-particle-list* array)
|
|
;; (define-extern birth-func-texture-group-steam-b-ctyindb function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; basebutton ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype basebutton (process-focusable)
|
|
((button-status uint16 :offset-assert 208) ;; button-status
|
|
(notify-actor entity :offset-assert 212) ;; guessed by decompiler
|
|
(actor-group (pointer actor-group) :offset-assert 216) ;; guessed by decompiler
|
|
(actor-group-count int32 :offset-assert 220)
|
|
(timeout float :offset-assert 224)
|
|
(button-id int32 :offset-assert 228)
|
|
(event-going-down symbol :offset-assert 232) ;; guessed by decompiler
|
|
(event-down symbol :offset-assert 236) ;; guessed by decompiler
|
|
(event-going-up symbol :offset-assert 240) ;; guessed by decompiler
|
|
(event-up symbol :offset-assert 244) ;; guessed by decompiler
|
|
(anim-speed float :offset-assert 248)
|
|
(move-to-pos vector :inline :offset-assert 256)
|
|
(move-to-quat quaternion :inline :offset-assert 272)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x120
|
|
:flag-assert #x2800a00120
|
|
(:methods
|
|
(basebutton-method-32 () none) ;; 32 ;; (idle-state-transition (_type_) object 32)
|
|
(basebutton-method-33 () none) ;; 33 ;; (basebutton-method-33 (_type_) none 33)
|
|
(basebutton-method-34 () none) ;; 34 ;; (basebutton-method-34 (_type_) none 34)
|
|
(basebutton-method-35 () none) ;; 35 ;; (prepare-trigger-event! (_type_) none 35)
|
|
(basebutton-method-36 () none) ;; 36 ;; (send-event! (_type_ symbol) none 36)
|
|
(basebutton-method-37 () none) ;; 37 ;; (move-to! (_type_ vector quaternion) none 37)
|
|
(basebutton-method-38 () none) ;; 38 ;; (press! (_type_ symbol) entity-perm-status 38)
|
|
(basebutton-method-39 () none) ;; 39
|
|
)
|
|
(:state-methods
|
|
up-idle ;; 31, old: (reset! (_type_) none 31)
|
|
going-down ;; 29, old: (going-up () _type_ :state 29)
|
|
down-idle ;; 28, old: (going-down () _type_ :state 28)
|
|
going-up ;; 30, old: (up-idle () _type_ :state 30)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern basebutton-init-by-other function) ;; (function entity-actor vector quaternion entity-actor symbol float none :behavior basebutton)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mine-obs-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mine-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rat-light-manager (process)
|
|
((actor-group uint32 :offset-assert 124)
|
|
(actor-group-count int32 :offset-assert 128)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x88
|
|
:flag-assert #x1100100088
|
|
(:methods
|
|
(rat-light-manager-method-15 () none) ;; 15
|
|
(rat-light-manager-method-16 () none) ;; 16
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-rat-engine (process-drawable)
|
|
((init-quat quaternion :inline :offset-assert 204)
|
|
(force-pos vector :inline :offset-assert 220)
|
|
(actor-group uint32 :offset-assert 236)
|
|
(actor-group-count int32 :offset-assert 240)
|
|
(rot-speed float :offset-assert 244)
|
|
(ang-momentum float :offset-assert 248)
|
|
(rat-timer uint64 :offset-assert 252)
|
|
(notify-actor basic :offset-assert 260)
|
|
(sound-id uint32 :offset-assert 264)
|
|
(rat-sound-id uint32 :offset-assert 268)
|
|
(rat-wheel-sound-id uint32 :offset-assert 272)
|
|
(light-index uint32 :offset-assert 276)
|
|
(light-target float :offset-assert 280)
|
|
(wheel-angle float :offset-assert 284)
|
|
(wheel-sound-volume float :offset-assert 288)
|
|
(last-turn-time uint64 :offset-assert 292)
|
|
(rat-count uint32 :offset-assert 300)
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #x134
|
|
:flag-assert #x1d00c00134
|
|
(:methods
|
|
(min-rat-engine-method-24 () none) ;; 24
|
|
(min-rat-engine-method-25 () none) ;; 25
|
|
(min-rat-engine-method-26 () none) ;; 26
|
|
(min-rat-engine-method-27 () none) ;; 27
|
|
(min-rat-engine-method-28 () none) ;; 28
|
|
)
|
|
(:state-methods
|
|
inactive ;; 20
|
|
active ;; 21
|
|
running ;; 22
|
|
shutdown ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-crane (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:methods
|
|
(min-crane-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-target-sign (mine-platform-base)
|
|
((off-part basic :offset-assert 272)
|
|
(on-part basic :offset-assert 276)
|
|
(track-pos vector :inline :offset-assert 288)
|
|
(alt-actor basic :offset-assert 304)
|
|
(touched-train? basic :offset-assert 308)
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x138
|
|
:flag-assert #x2b00c00138
|
|
(:methods
|
|
(min-target-sign-method-42 () none) ;; 42
|
|
)
|
|
(:state-methods
|
|
dormant ;; 38
|
|
idle ;; 39
|
|
lowering ;; 40
|
|
idle-down ;; 41
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-bomb-elevator (elevator)
|
|
((alt-actor basic :offset-assert 416)
|
|
(bomb-train-offset float :offset-assert 420)
|
|
(wheel-angle float :offset-assert 424)
|
|
)
|
|
:method-count-assert 52
|
|
:size-assert #x1ac
|
|
:flag-assert #x34013001ac
|
|
(:state-methods
|
|
waiting ;; 36
|
|
running ;; 37
|
|
arrived ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-elev-doors (process-drawable)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
(:methods
|
|
(min-elev-doors-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
open ;; 21
|
|
opened ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-crane-switch (basebutton)
|
|
((rog uint64 :offset-assert 288)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x128
|
|
:flag-assert #x2800b00128
|
|
(:state-methods
|
|
down-idle ;; 28
|
|
up-idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-door (process-drawable)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
(:methods
|
|
(min-door-method-22 () none) ;; 22
|
|
(min-door-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
exploded ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-elec-gate (elec-gate)
|
|
()
|
|
:method-count-assert 31
|
|
:size-assert #x200
|
|
:flag-assert #x1f01800200
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-boss-elev (elevator)
|
|
((going-down? basic :offset-assert 416)
|
|
(sound-rotating-loop basic :offset-assert 420)
|
|
)
|
|
:method-count-assert 52
|
|
:size-assert #x1a8
|
|
:flag-assert #x34013001a8
|
|
(:state-methods
|
|
dormant ;; 35
|
|
running ;; 37
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype min-airlock-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mine-music-manager (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern mineb-activate function)
|
|
;; (define-extern min-rat-engine-handler function)
|
|
;; (define-extern min-rat-engine-post function)
|
|
;; (define-extern joint-mod-rat-engine-callback function)
|
|
;; (define-extern target-sign-event-handler function)
|
|
;; (define-extern min-bomb-elevator-callback function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; manta ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype manta (nav-enemy)
|
|
((info rigid-body-object-constants :offset-assert 616)
|
|
(move-matrix matrix :inline :offset-assert 620)
|
|
(curve-matrix matrix :inline :offset-assert 684)
|
|
(move-vel vector :inline :offset-assert 748)
|
|
(move-u float :offset-assert 764)
|
|
(move-du float :offset-assert 768)
|
|
(move-force float :offset-assert 772)
|
|
(flags uint16 :offset-assert 776)
|
|
(go-enable basic :offset-assert 780)
|
|
(orbit-speed float :offset-assert 784)
|
|
(max-time-step float :offset-assert 788)
|
|
(gravity float :offset-assert 792)
|
|
(landed-pos vector :inline :offset-assert 796)
|
|
(dest-pos vector :inline :offset-assert 812)
|
|
(attack-pos vector :inline :offset-assert 828)
|
|
(up-dir vector :inline :offset-assert 844)
|
|
(forward-dir vector :inline :offset-assert 860)
|
|
(knocked-force vector :inline :offset-assert 876)
|
|
(knocked-force-mult float :offset-assert 892)
|
|
(default-y-offset float :offset-assert 896)
|
|
(y-offset float :offset-assert 900)
|
|
(last-attack-time uint64 :offset-assert 908)
|
|
(attack-y-offset float :offset-assert 916)
|
|
(attack-path-blocked-time uint64 :offset-assert 924)
|
|
(track-timer uint64 :offset-assert 932)
|
|
(angle-to-player float :offset-assert 940)
|
|
(offset-difference float :offset-assert 944)
|
|
(sound-volume float :offset-assert 948)
|
|
(restart-fly-anims basic :offset-assert 952)
|
|
(fly-anim-speed float :offset-assert 956)
|
|
(hit-ground-count uint32 :offset-assert 960)
|
|
(fade-level float :offset-assert 964)
|
|
(actor-group uint32 :offset-assert 496)
|
|
(actor-group-count int32 :offset-assert 500)
|
|
)
|
|
:method-count-assert 209
|
|
:size-assert #x3d4
|
|
:flag-assert #xd1036003d4
|
|
(:methods
|
|
(manta-method-195 () none) ;; 195
|
|
(manta-method-196 () none) ;; 196
|
|
(manta-method-197 () none) ;; 197
|
|
(manta-method-198 () none) ;; 198
|
|
(manta-method-199 () none) ;; 199
|
|
(manta-method-200 () none) ;; 200
|
|
(manta-method-201 () none) ;; 201
|
|
(manta-method-202 () none) ;; 202
|
|
(manta-method-203 () none) ;; 203
|
|
(manta-method-204 () none) ;; 204
|
|
(manta-method-205 () none) ;; 205
|
|
(manta-method-206 () none) ;; 206
|
|
(manta-method-207 () none) ;; 207
|
|
(manta-method-208 () none) ;; 208
|
|
)
|
|
(:state-methods
|
|
idle ;; 33
|
|
hostile ;; 38
|
|
land-approach ;; 190
|
|
ambush ;; 47
|
|
land ;; 191
|
|
active ;; 34
|
|
notice-to-fly ;; 192
|
|
stare ;; 37
|
|
attack ;; 193
|
|
attack-end ;; 194
|
|
knocked ;; 31
|
|
knocked-recover ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *manta-rigid-body-constants* object)
|
|
;; (define-extern *fact-info-manta-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *manta-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern manta-hostile-post function)
|
|
;; (define-extern manta-attack-post function)
|
|
;; (define-extern manta-fly-code function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rat ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rat (nav-enemy)
|
|
((init-quat quaternion :inline :offset-assert 624)
|
|
(roll-transform transformq :inline :offset-assert 640)
|
|
(face-dir vector :inline :offset-assert 688)
|
|
(flee-focus-pos vector :inline :offset-assert 704)
|
|
(wheel-actor basic :offset-assert 720)
|
|
(permanently-scared basic :offset-assert 724)
|
|
(slide-sound-id uint32 :offset-assert 728)
|
|
(scared-timer uint64 :offset-assert 736)
|
|
(scared-interval uint64 :offset-assert 744)
|
|
(return-to-nav-mesh? basic :offset-assert 752)
|
|
)
|
|
:method-count-assert 198
|
|
:size-assert #x2f4
|
|
:flag-assert #xc6028002f4
|
|
(:methods
|
|
(rat-method-195 () none) ;; 195
|
|
)
|
|
(:state-methods
|
|
idle ;; 33
|
|
wait-by-wheel-wait ;; 191
|
|
ambush ;; 47
|
|
active ;; 34
|
|
active-turn ;; 192
|
|
notice ;; 35
|
|
hostile ;; 38
|
|
wait-by-wheel-seek ;; 190
|
|
attack ;; 193
|
|
flee ;; 36
|
|
flee-stare ;; 194
|
|
stare ;; 37
|
|
knocked ;; 31
|
|
knocked-recover ;; 32
|
|
running-in-wheel ;; 196
|
|
wheel-die ;; 197
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rat-spawner (process)
|
|
((rats-spawned uint32 :offset-assert 124)
|
|
(wheel-entity basic :offset-assert 128)
|
|
(state-time uint64 :offset-assert 132)
|
|
(active? basic :offset-assert 140)
|
|
(rats-to-spawn uint32 :offset-assert 144)
|
|
(actor-group uint32 :offset-assert 148)
|
|
(actor-group-count int32 :offset-assert 152)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #xa0
|
|
:flag-assert #x10002000a0
|
|
(:state-methods
|
|
idle ;; 14
|
|
die ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-rat-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *rat-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern rat-run-code function)
|
|
;; (define-extern rat-falling-post function)
|
|
;; (define-extern rat-joint-mod-roll function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; des-beast ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype beast-grenade (projectile-bounce)
|
|
((blast-radius float :offset-assert 548)
|
|
)
|
|
:method-count-assert 45
|
|
:size-assert #x228
|
|
:flag-assert #x2d01b00228
|
|
(:methods
|
|
(beast-grenade-method-44 () none) ;; 44
|
|
)
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype beast-rider (enemy)
|
|
()
|
|
:method-count-assert 155
|
|
:size-assert #x228
|
|
:flag-assert #x9b01b00228
|
|
(:state-methods
|
|
idle ;; 33
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-beast (enemy)
|
|
((path-pos float :offset-assert 552)
|
|
(path-pos-speed float :offset-assert 556)
|
|
(speed-factor float :offset-assert 560)
|
|
(main-speed-factor float :offset-assert 564)
|
|
(main-speed-factor-dest float :offset-assert 568)
|
|
(des-path desbeast-path :offset-assert 572)
|
|
(angle-turret float :offset-assert 580)
|
|
(angle-gun float :offset-assert 584)
|
|
(run-start-frame float :offset-assert 588)
|
|
(can-turn? basic :offset-assert 592)
|
|
(behind-time uint64 :offset-assert 600)
|
|
(target-gun-pos vector :inline :offset-assert 608)
|
|
(incoming-attack-id uint32 :offset-assert 624)
|
|
(hit-points2 float :offset-assert 632)
|
|
(angry float :offset-assert 636)
|
|
(attack-next? basic :offset-assert 640)
|
|
(minimap connection-minimap :offset-assert 644)
|
|
(s-clock float :offset-assert 648)
|
|
(attack-id-time uint64 :offset-assert 656)
|
|
(oomass float :offset-assert 664)
|
|
(jitter float :offset-assert 668)
|
|
(next-shoot uint64 :offset-assert 672)
|
|
(shoot-delay uint64 :offset-assert 680)
|
|
(manager uint64 :offset-assert 688)
|
|
(hit-part basic :offset-assert 696)
|
|
)
|
|
:method-count-assert 168
|
|
:size-assert #x2bc
|
|
:flag-assert #xa8024002bc
|
|
(:methods
|
|
(des-beast-method-160 () none) ;; 160
|
|
(des-beast-method-161 () none) ;; 161
|
|
(des-beast-method-162 () none) ;; 162
|
|
(des-beast-method-163 () none) ;; 163
|
|
(des-beast-method-164 () none) ;; 164
|
|
(des-beast-method-165 () none) ;; 165
|
|
(des-beast-method-166 () none) ;; 166
|
|
(des-beast-method-167 () none) ;; 167
|
|
)
|
|
(:state-methods
|
|
idle ;; 33
|
|
turn-back ;; 155
|
|
falling ;; 156
|
|
die-run ;; 159
|
|
down ;; 157
|
|
get-up ;; 158
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *curve-beast-linear-up-red* object)
|
|
;; (define-extern *trail-color-curve-grenade* curve-color-fast)
|
|
;; (define-extern *curve-grenade-linear-trail* curve2d-fast)
|
|
;; (define-extern *beast-grenade-trail* object)
|
|
;; (define-extern spt-birth-func-brightness-grenade-bits function)
|
|
;; (define-extern spt-birth-func-part-grenade-explosion-bits function)
|
|
;; (define-extern *range-grenade-explo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-grenade-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-grenade-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-grenade-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-grenade-explo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-grenade-explo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-grenade-explo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-grenade-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-grenade-explo-color* curve-color-fast)
|
|
;; (define-extern *range-grenade-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-grenade-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-grenade-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-grenade-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-grenade-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-grenade-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-grenade-explosion-texture-curve-settings* object)
|
|
;; (define-extern spt-birth-func-part-beast-fall-bits function)
|
|
;; (define-extern spt-birth-func-part-beast-foot-bits function)
|
|
;; (define-extern *beast-rider-enemy-info* enemy-info)
|
|
;; (define-extern *des-beast-enemy-info* enemy-info)
|
|
;; (define-extern beast-rider-init-by-other function)
|
|
;; (define-extern *beast-camera-slow-motion* object)
|
|
;; (define-extern des-beast-active-post function)
|
|
;; (define-extern des-beast-gun-swivel-callback function)
|
|
;; (define-extern des-beast-gun-callback function)
|
|
;; (define-extern des-beast-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; des-beast-2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype quantum-reflector (process-focusable)
|
|
((rod uint64 :offset-assert 208)
|
|
(minimap connection-minimap :offset-assert 216)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #xdc
|
|
:flag-assert #x1f006000dc
|
|
(:state-methods
|
|
hidden ;; 28
|
|
idle ;; 29
|
|
die ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype beast-grenade-2 (projectile-bounce)
|
|
((minimap connection-minimap :offset-assert 548)
|
|
(blast-damage basic :offset-assert 552)
|
|
(blast-radius float :offset-assert 556)
|
|
)
|
|
:method-count-assert 45
|
|
:size-assert #x230
|
|
:flag-assert #x2d01b00230
|
|
(:methods
|
|
(beast-grenade-2-method-44 () none) ;; 44
|
|
)
|
|
(:state-methods
|
|
moving ;; 23
|
|
impact ;; 22
|
|
dissipate ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-beast-2 (des-beast)
|
|
((focus-vel vector :inline :offset-assert 704)
|
|
(shot-velocity vector :inline :offset-assert 720)
|
|
(vehicle-handle uint64 :offset-assert 736)
|
|
(pickup-handle uint64 :offset-assert 744)
|
|
(shot-count uint32 :offset-assert 752)
|
|
(follow-distance float :offset-assert 756)
|
|
(anim-interp float :offset-assert 760)
|
|
(last-beast basic :offset-assert 764)
|
|
)
|
|
:method-count-assert 168
|
|
:size-assert #x300
|
|
:flag-assert #xa802800300
|
|
(:state-methods
|
|
hostile ;; 38
|
|
die-run ;; 159
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; beast-battle-path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *desbeast-battle-path-table* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-protect ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-protect-hq (task-manager)
|
|
((gunships UNKNOWN 2 :offset-assert 240)
|
|
(spawn-records basic :offset-assert 256)
|
|
(spawn-index int8 :offset-assert 260)
|
|
(death-count int8 :offset-assert 261)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x106
|
|
:flag-assert #x2600900106
|
|
(:methods
|
|
(task-manager-protect-hq-method-35 () none) ;; 35
|
|
(task-manager-protect-hq-method-36 () none) ;; 36
|
|
(task-manager-protect-hq-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
wait ;; 14
|
|
active ;; 15
|
|
fight-gunship ;; 32
|
|
wait-finish ;; 34
|
|
fail ;; 18
|
|
fight-gunship-2 ;; 33
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prot-crate (process-drawable)
|
|
((h-crate uint64 :offset-assert 208)
|
|
(dummy-ent basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xdc
|
|
:flag-assert #x16006000dc
|
|
(:methods
|
|
(prot-crate-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *protect-object-count* array)
|
|
;; (define-extern protect-type->type function)
|
|
;; (define-extern *protect-levels* array)
|
|
;; (define-extern spawn-protect-enemy function)
|
|
;; (define-extern *gunship-start-positions* array)
|
|
;; (define-extern *fountain-center-pos* object)
|
|
;; (define-extern get-protect-suck-t function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; scorpion-gun ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype speecher (structure)
|
|
((speech-array basic :offset-assert 0)
|
|
(next-index uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x8
|
|
:flag-assert #xb00000008
|
|
(:methods
|
|
(speecher-method-9 () none) ;; 9
|
|
(speecher-method-10 () none) ;; 10
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-scorpion-gun (hud)
|
|
((offscreen uint8 :offset-assert 2756)
|
|
(alpha UNKNOWN 2 :offset-assert 2760)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xad0
|
|
:flag-assert #x1b0a500ad0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype scorpion-gun-aim (process)
|
|
((hud-aim hud-sprite :inline :offset-assert 128)
|
|
(screen-pos vector :inline :offset-assert 192)
|
|
(color uint32 :offset-assert 208)
|
|
(draw? basic :offset-assert 212)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #xd8
|
|
:flag-assert #xf006000d8
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype scorpion-gun-shot (projectile)
|
|
((init-pos vector :inline :offset-assert 512)
|
|
(init-dir vector :inline :offset-assert 528)
|
|
(collide-normal vector :inline :offset-assert 544)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x230
|
|
:flag-assert #x2901b00230
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype scorpion-gun (process-drawable)
|
|
((aim-dir vector :inline :offset-assert 208)
|
|
(scorp-quat quaternion :inline :offset-assert 224)
|
|
(scorp-smooth-quat quaternion :inline :offset-assert 240)
|
|
(scorp uint64 :offset-assert 256)
|
|
(manager uint64 :offset-assert 264)
|
|
(hud-aim uint64 :offset-assert 272)
|
|
(barrel-spin-angle float :offset-assert 280)
|
|
(barrel-spin-rate float :offset-assert 284)
|
|
(barrel-kick float :offset-assert 288)
|
|
(last-fire-time uint64 :offset-assert 296)
|
|
(valid-target-time uint64 :offset-assert 304)
|
|
(valid-target-anim-time uint64 :offset-assert 312)
|
|
(target-handle uint64 :offset-assert 320)
|
|
(rotx float :offset-assert 328)
|
|
(rotxv float :offset-assert 332)
|
|
(rotxvv float :offset-assert 336)
|
|
(roty float :offset-assert 340)
|
|
(rotyv float :offset-assert 344)
|
|
(rotyvv float :offset-assert 348)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x160
|
|
:flag-assert #x1a00e00160
|
|
(:methods
|
|
(scorpion-gun-method-24 () none) ;; 24
|
|
(scorpion-gun-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
firing ;; 22
|
|
die ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype scorpion-gun-spawn-info (structure)
|
|
((enemy-to-spawn basic :offset-assert 0)
|
|
(spawn-u float :offset-assert 4)
|
|
(use-path-index int32 :offset-assert 8)
|
|
(follow-distance float :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype scorpion-gun-manager-path (structure)
|
|
((path desbeast-path :offset-assert 0)
|
|
(curr-pos float :offset-assert 4)
|
|
(next-pos int32 :offset-assert 8)
|
|
(prev-pos int32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype scorpion-gun-manager (process)
|
|
((trans vector :inline :offset-assert 128)
|
|
(quat quaternion :inline :offset-assert 144)
|
|
(speecher-on-start speecher :inline :offset-assert 160)
|
|
(speecher-on-beast-death speecher :inline :offset-assert 168)
|
|
(speecher-on-damage speecher :inline :offset-assert 176)
|
|
(speecher-on-beast-triggered speecher :inline :offset-assert 184)
|
|
(speecher-on-flyer-triggered speecher :inline :offset-assert 192)
|
|
(state-time uint64 :offset-assert 200)
|
|
(path-info scorpion-gun-manager-path :inline :offset-assert 208)
|
|
(enemy UNKNOWN 36 :offset-assert 224)
|
|
(last-beast uint64 :offset-assert 512)
|
|
(gun uint64 :offset-assert 520)
|
|
(scorp uint64 :offset-assert 528)
|
|
(hud-health uint64 :offset-assert 536)
|
|
(hud-arrows uint64 :offset-assert 544)
|
|
(use-camera basic :offset-assert 552)
|
|
(last-scorpion-hit-points float :offset-assert 556)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #x230
|
|
:flag-assert #x1701b00230
|
|
(:methods
|
|
(scorpion-gun-manager-method-21 () none) ;; 21
|
|
(scorpion-gun-manager-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
setup ;; 15
|
|
active ;; 16
|
|
shutdown ;; 17
|
|
fail ;; 18
|
|
restart ;; 19
|
|
die-fast ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *desert-beast-speech-list* object)
|
|
;; (define-extern scorpion-gun-aim-init-by-other function)
|
|
;; (define-extern scorpion-gun-shot-move function)
|
|
;; (define-extern scorpion-gun-handler function)
|
|
;; (define-extern quaternion-seek-by-angle! function)
|
|
;; (define-extern control-post function)
|
|
;; (define-extern aim-post function)
|
|
;; (define-extern scorpion-gun-init-by-other function)
|
|
;; (define-extern *scorpion-beast-spawn-info* array)
|
|
;; (define-extern scorpion-gun-manager-handler function)
|
|
;; (define-extern beast-post function)
|
|
;; (define-extern cam-scorpion-gun state)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lfacrm2-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fac-elevator-a (elevator)
|
|
((mysound uint32 :offset-assert 416)
|
|
)
|
|
:method-count-assert 52
|
|
:size-assert #x1a4
|
|
:flag-assert #x34013001a4
|
|
(:state-methods
|
|
running ;; 37
|
|
arrived ;; 38
|
|
waiting ;; 36
|
|
dormant ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lfacrm2-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-lfacrm2 function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; was-pre-game ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype was-pre-game-wave (structure)
|
|
((event-count-min int16 :offset-assert 0)
|
|
(event-count-max int16 :offset-assert 2)
|
|
(bubble-count-min int16 :offset-assert 4)
|
|
(bubble-count-max int16 :offset-assert 6)
|
|
(event-interval uint16 :offset-assert 8)
|
|
(delay uint16 :offset-assert 10)
|
|
(gravity-min meters :offset-assert 12)
|
|
(gravity-max meters :offset-assert 16)
|
|
(beam-offset-max float :offset-assert 20)
|
|
(beam-size-min float :offset-assert 24)
|
|
(beam-size-max float :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype was-pre-game-game (structure)
|
|
((point-win float :offset-assert 0)
|
|
(miss-max float :offset-assert 4)
|
|
(wave uint32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype was-pre-beam-info (structure)
|
|
((index int32 :offset-assert 0)
|
|
(min float :offset-assert 4)
|
|
(size float :offset-assert 8)
|
|
(fire-time uint64 :offset-assert 16)
|
|
(beam uint64 :offset-assert 24)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x20
|
|
:flag-assert #xa00000020
|
|
(:methods
|
|
(was-pre-beam-info-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype was-pre-beam (process-drawable)
|
|
((index int32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
attack ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype was-pre-heart (process-drawable)
|
|
((cur-level int32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype was-pre-game (process-drawable)
|
|
((task basic :offset-assert 200)
|
|
(hud-score uint64 :offset-assert 208)
|
|
(hud-goal uint64 :offset-assert 216)
|
|
(hud-miss uint64 :offset-assert 224)
|
|
(score float :offset-assert 232)
|
|
(score-time uint64 :offset-assert 240)
|
|
(miss-max int32 :offset-assert 248)
|
|
(miss-count int32 :offset-assert 252)
|
|
(miss-time uint64 :offset-assert 256)
|
|
(point-win float :offset-assert 264)
|
|
(game was-pre-game-game :offset-assert 268)
|
|
(game-start-time uint64 :offset-assert 272)
|
|
(wave-start-time uint64 :offset-assert 280)
|
|
(event-start-time uint64 :offset-assert 288)
|
|
(wave-index int32 :offset-assert 296)
|
|
(event-index int32 :offset-assert 300)
|
|
(event-count int32 :offset-assert 304)
|
|
(beam-clock float :offset-assert 308)
|
|
(speech-time uint64 :offset-assert 312)
|
|
(speech-count int32 :offset-assert 320)
|
|
(speech-last UNKNOWN 4 :offset-assert 324)
|
|
(screen-matrix matrix :inline :offset-assert 352)
|
|
(screen-scale vector :inline :offset-assert 416)
|
|
(spawn-time uint64 :offset-assert 432)
|
|
(beam UNKNOWN 4 :offset-assert 440)
|
|
(heart uint64 :offset-assert 568)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x240
|
|
:flag-assert #x2201c00240
|
|
(:methods
|
|
(was-pre-game-method-26 () none) ;; 26
|
|
(was-pre-game-method-27 () none) ;; 27
|
|
(was-pre-game-method-28 () none) ;; 28
|
|
(was-pre-game-method-29 () none) ;; 29
|
|
(was-pre-game-method-30 () none) ;; 30
|
|
(was-pre-game-method-31 () none) ;; 31
|
|
(was-pre-game-method-32 () none) ;; 32
|
|
(was-pre-game-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
hide ;; 21
|
|
idle ;; 20
|
|
wait-for-start ;; 22
|
|
active ;; 23
|
|
lose ;; 24
|
|
win ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pre-game-bubble (process-drawable)
|
|
((screen-pos vector :inline :offset-assert 208)
|
|
(bubble-type int32 :offset-assert 224)
|
|
(bubble-start-time uint64 :offset-assert 232)
|
|
(start-delay uint64 :offset-assert 240)
|
|
(gravity meters :offset-assert 248)
|
|
(dead? basic :offset-assert 252)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #x100
|
|
:flag-assert #x1600800100
|
|
(:state-methods
|
|
idle ;; 20
|
|
fall ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern birth-func-pre-bubble-pop function)
|
|
;; (define-extern birth-func-pre-bubble-birth-pop function)
|
|
;; (define-extern *pre-game* object)
|
|
;; (define-extern *pre-game-fun* object)
|
|
;; (define-extern pre-game-bubble-init function)
|
|
;; (define-extern was-pre-beam-init function)
|
|
;; (define-extern was-pre-heart-init function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; metalhead-predator ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype metalhead-predator-shot (metalhead-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x210
|
|
:flag-assert #x2901900210
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype metalhead-predator (mh-squad-member)
|
|
((los los-control :inline :offset-assert 1088)
|
|
(want-stop symbol :offset-assert 1252) ;; guessed by decompiler
|
|
(target-pos vector :inline :offset-assert 1264)
|
|
(curr-node int32 :offset-assert 1280)
|
|
(hide-pos vector :inline :offset-assert 1296)
|
|
(next-change uint64 :offset-assert 1312) ;; int64
|
|
(shoot-angle float :offset-assert 1320) ;; degrees
|
|
(miss-amount float :offset-assert 1324)
|
|
(ambient-sound-id sound-id :offset-assert 1328) ;; guessed by decompiler
|
|
(shock-effect-time uint64 :offset-assert 1336) ;; time-frame
|
|
(shock-effect-end uint64 :offset-assert 1344) ;; int64
|
|
(fade float :offset-assert 1352)
|
|
(dest-fade float :offset-assert 1356)
|
|
)
|
|
:method-count-assert 228
|
|
:size-assert #x550
|
|
:flag-assert #xe404d00550
|
|
(:methods
|
|
(metalhead-predator-method-224 () none) ;; 224
|
|
(metalhead-predator-method-225 () none) ;; 225
|
|
(metalhead-predator-method-226 () none) ;; 226
|
|
(metalhead-predator-method-227 () none) ;; 227
|
|
)
|
|
(:state-methods
|
|
active ;; 34
|
|
die-fast ;; 42
|
|
hostile ;; 38
|
|
fire ;; 222
|
|
close-attack ;; 223
|
|
in-ditch ;; 192
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *metalhead-predator-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; templex-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-color-templex-big-torch-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-templex-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-templex-big-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-templex-big-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-templex-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-templex-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-templex-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-templex-big-torch-flame* curve2d-fast)
|
|
;; (define-extern *curve-templex-big-torch-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-templex-big-torch-flame-y* curve2d-fast)
|
|
;; (define-extern *part-templex-big-torch-flame-curve-settings* object)
|
|
;; (define-extern *range-color-templex-fire-vase-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-templex-fire-vase-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-templex-fire-vase-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-templex-fire-vase-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-templex-fire-vase-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-templex-fire-vase-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-templex-fire-vase-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-templex-fire-vase-flame* curve2d-fast)
|
|
;; (define-extern *curve-templex-fire-vase-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-templex-fire-vase-flame-y* curve2d-fast)
|
|
;; (define-extern *part-templex-fire-vase-flame-curve-settings* object)
|
|
;; (define-extern *range-color-templex-fire-vase-large-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-templex-fire-vase-large-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-templex-fire-vase-large-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-templex-fire-vase-large-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-templex-fire-vase-large-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-templex-fire-vase-large-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-templex-fire-vase-large-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-templex-fire-vase-large-flame* curve2d-fast)
|
|
;; (define-extern *curve-templex-fire-vase-large-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-templex-fire-vase-large-flame-y* curve2d-fast)
|
|
;; (define-extern *part-templex-fire-vase-large-flame-curve-settings* object)
|
|
;; (define-extern *range-color-templex-fire-vase-small-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-templex-fire-vase-small-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-templex-fire-vase-small-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-templex-fire-vase-small-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-templex-fire-vase-small-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-templex-fire-vase-small-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-templex-fire-vase-small-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-templex-fire-vase-small-flame* curve2d-fast)
|
|
;; (define-extern *curve-templex-fire-vase-small-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-templex-fire-vase-small-flame-y* curve2d-fast)
|
|
;; (define-extern *part-templex-fire-vase-small-flame-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; terraformer-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-ter-wsplash-color* curve-color-fast)
|
|
;; (define-extern *range-ter-wsplash-alpha* curve2d-fast)
|
|
;; (define-extern *range-ter-wsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ter-wsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ter-wsplash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ter-wsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ter-wsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-ter-water-splash-curve-settings* object)
|
|
;; (define-extern *range-ter-splash-color* curve-color-fast)
|
|
;; (define-extern *range-ter-splash-alpha* curve2d-fast)
|
|
;; (define-extern *range-ter-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ter-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ter-splash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ter-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ter-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-ter-water-splash-center-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; freehq-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern part-freehq-sphere-vert-line-flicker function)
|
|
;; (define-extern birth-func-freehq-sphere function)
|
|
;; (define-extern sparticle-kill-at-scale-eqline function)
|
|
;; (define-extern sparticle-kill-at-scale-mediumb function)
|
|
;; (define-extern sparticle-kill-at-scale function)
|
|
;; (define-extern sparticle-kill-at-scale-squares function)
|
|
;; (define-extern *range-landscape-scale-x* curve2d-fast)
|
|
;; (define-extern *range-landscape-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-landscape-scale-x-temp* curve2d-fast)
|
|
;; (define-extern *curve-landscape-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-landscape-scale-y* curve2d-fast)
|
|
;; (define-extern *part-freehq-giant-landscape-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; freehq-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype freehq-sml-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tower-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; waswide-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-birth-func-brightness-sat-scrape-dirt function)
|
|
;; (define-extern spt-birth-func-part-sat-scrape-dirt function)
|
|
;; (define-extern spt-birth-func-part-sat-scrape-rocks function)
|
|
;; (define-extern *range-sat-explo-scene-color* curve-color-fast)
|
|
;; (define-extern *range-sat-explo-scene-alpha* curve2d-fast)
|
|
;; (define-extern *range-sat-explo-scene-scale-x* curve2d-fast)
|
|
;; (define-extern *range-sat-explo-scene-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-scene-alpha* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-scene-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-scene-scale-y* curve2d-fast)
|
|
;; (define-extern *part-neo-satellite-explosion-texture-scene-curve-settings* object)
|
|
;; (define-extern *range-color-wascity-palace-fire-beacon-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-wascity-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-wascity-palace-fire-beacon-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-wascity-palace-fire-beacon-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-wascity-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-wascity-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-wascity-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-wascity-palace-fire-beacon-flame* curve2d-fast)
|
|
;; (define-extern *curve-wascity-palace-fire-beacon-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-wascity-palace-fire-beacon-flame-y* curve2d-fast)
|
|
;; (define-extern *part-wascity-palace-fire-beacon-flame-curve-settings* object)
|
|
;; (define-extern *range-wrsplash-color* curve-color-fast)
|
|
;; (define-extern *range-wrsplash-alpha* curve2d-fast)
|
|
;; (define-extern *range-wrsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-wrsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-wrsplash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-wrsplash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-wrsplash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-water-rocks-splash-curve-settings* object)
|
|
;; (define-extern part-wascityb-bird1-path function)
|
|
;; (define-extern part-wascityb-bird2-path function)
|
|
;; (define-extern part-wascityb-bird3-path function)
|
|
;; (define-extern part-wascityb-bird4-path function)
|
|
;; (define-extern part-wascityb-bird5-path function)
|
|
;; (define-extern part-wascityb-bird6-path function)
|
|
;; (define-extern part-wascityb-bird7-path function)
|
|
;; (define-extern part-wascityb-bird8-path function)
|
|
;; (define-extern part-wascityb-bird9-path function)
|
|
;; (define-extern part-wascityb-bird10-path function)
|
|
;; (define-extern part-wascitya-fly1-path function)
|
|
;; (define-extern part-wascitya-fly2-path function)
|
|
;; (define-extern part-wascitya-fly3-path function)
|
|
;; (define-extern *range-color-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-flame* curve2d-fast)
|
|
;; (define-extern *curve-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-flame-y* curve2d-fast)
|
|
;; (define-extern *part-gas-lamp-flame-curve-settings* object)
|
|
;; (define-extern *part-talltorch-flame-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tower-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype actor-group-watcher (process)
|
|
((actor-group uint32 :offset-assert 124)
|
|
(actor-group-count int32 :offset-assert 128)
|
|
(notify-actor basic :offset-assert 132)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x8c
|
|
:flag-assert #x100010008c
|
|
(:state-methods
|
|
idle ;; 14
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tow-large-plat (process-drawable)
|
|
((actor-group uint32 :offset-assert 196)
|
|
(actor-group-count int32 :offset-assert 200)
|
|
(final-y float :offset-assert 204)
|
|
(fade-level float :offset-assert 208)
|
|
(sound-id uint32 :offset-assert 212)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xdc
|
|
:flag-assert #x1a006000dc
|
|
(:state-methods
|
|
idle ;; 20
|
|
lower ;; 21
|
|
lowered ;; 22
|
|
wait-to-trigger-movie ;; 23
|
|
trigger-movie ;; 24
|
|
die ;; 25
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tow-energy-bridge (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
extending ;; 21
|
|
active ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tow-spawner (process-drawable)
|
|
((spawn-time uint64 :offset-assert 200)
|
|
(spawn-count int32 :offset-assert 208)
|
|
(spawn-count-final int32 :offset-assert 212)
|
|
(nav-mesh basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xdc
|
|
:flag-assert #x1b006000dc
|
|
(:methods
|
|
(tow-spawner-method-25 () none) ;; 25
|
|
(tow-spawner-method-26 () none) ;; 26
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
spawning ;; 22
|
|
wait-for-children ;; 23
|
|
done ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tow-tentacle (process-drawable)
|
|
((attack-id int32 :offset-assert 200)
|
|
(no-collision-timer uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xd8
|
|
:flag-assert #x15006000d8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-tower-destroy (task-manager)
|
|
((creak-sound-id uint32 :offset-assert 240)
|
|
(creak-sound-timer uint64 :offset-assert 248)
|
|
(creak-sound-duration uint64 :offset-assert 256)
|
|
(goo-sound-id uint32 :offset-assert 264)
|
|
(goo-sound-timer uint64 :offset-assert 272)
|
|
(goo-sound-duration uint64 :offset-assert 280)
|
|
(goo-sound-playing basic :offset-assert 288)
|
|
(goo-sound-location vector :inline :offset-assert 304)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x140
|
|
:flag-assert #x2000c00140
|
|
)
|
|
|#
|
|
|
|
;; (define-extern towera-login function)
|
|
;; (define-extern towera-logout function)
|
|
;; (define-extern towera-activate function)
|
|
;; (define-extern wait-for-battle state)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-destroy-grid ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype jinx-hud (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype jinx (civilian)
|
|
((min-speed float :offset-assert 1124)
|
|
(max-speed float :offset-assert 1128)
|
|
(follow-offset float :offset-assert 1132)
|
|
(travel-anim-interp float :offset-assert 1136)
|
|
(travel-prev-ry float :offset-assert 1140)
|
|
(travel-prev-ry1 float :offset-assert 1144)
|
|
(player-blocking float :offset-assert 1148)
|
|
(follow-dir vector :inline :offset-assert 1152)
|
|
(destination vector :inline :offset-assert 1168)
|
|
(nav-mesh-aid uint32 :offset-assert 1184)
|
|
(health-handle uint64 :offset-assert 1192) ;; handle
|
|
(box-time float :offset-assert 1200)
|
|
(attacker-info city-attacker-info :offset-assert 1016)
|
|
(mission-squad basic :offset-assert 1020)
|
|
(jinx-flags uint32 :offset-assert 1212)
|
|
)
|
|
:method-count-assert 246
|
|
:size-assert #x4c0
|
|
:flag-assert #xf6044004c0
|
|
(:methods
|
|
(jinx-method-237 () none) ;; 237
|
|
(jinx-method-240 () none) ;; 240
|
|
(jinx-method-241 () none) ;; 241
|
|
(jinx-method-242 () none) ;; 242
|
|
(jinx-method-243 () none) ;; 243
|
|
(jinx-method-244 () none) ;; 244
|
|
(jinx-method-245 () none) ;; 245
|
|
)
|
|
(:state-methods
|
|
wait-for-ride ;; 223
|
|
knocked-recover ;; 32
|
|
move-to-vehicle ;; 224
|
|
board-vehicle ;; 225
|
|
traveling ;; 235
|
|
exit-vehicle ;; 227
|
|
waiting-idle ;; 236
|
|
go-power-box ;; 238
|
|
do-power-box ;; 239
|
|
traveling-blocked ;; 234
|
|
die-fast ;; 42
|
|
die ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-city-destroy-grid (task-manager)
|
|
((jinx uint64 :offset-assert 236)
|
|
(actor-group uint32 :offset-assert 244)
|
|
(actor-group-count int32 :offset-assert 248)
|
|
(next-box uint32 :offset-assert 252)
|
|
(arrow-h uint64 :offset-assert 260)
|
|
(goal-pos vector :inline :offset-assert 268)
|
|
(goal-pos-front vector :inline :offset-assert 284)
|
|
(sub-state uint32 :offset-assert 300)
|
|
(vehicle uint64 :offset-assert 308)
|
|
(wall-h uint64 :offset-assert 316)
|
|
(sound-name basic :offset-assert 324)
|
|
(id uint32 :offset-assert 328)
|
|
(delay uint64 :offset-assert 332)
|
|
(delay-start uint64 :offset-assert 340)
|
|
(start-time uint64 :offset-assert 164)
|
|
(end-time uint64 :offset-assert 356)
|
|
(intro-play? basic :offset-assert 364)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x174
|
|
:flag-assert #x2201000174
|
|
(:methods
|
|
(task-manager-city-destroy-grid-method-32 () none) ;; 32
|
|
(task-manager-city-destroy-grid-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
wait ;; 14
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype com-power-box (process-drawable)
|
|
((sound-id uint32 :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *jinx-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern *citizen-jinx-global-info* civilian-global-info)
|
|
;; (define-extern board-vehicle-get-in-car-jump function)
|
|
;; (define-extern board-vehicle-get-in-car-land function)
|
|
;; (define-extern board-vehicle-get-in-car-sit function)
|
|
;; (define-extern board-vehicle-get-in-car-end function)
|
|
;; (define-extern *cty-destroy-grid-kg-squad-member-settings* object)
|
|
;; (define-extern *cty-destroy-grid-mh-squad-member-settings* object)
|
|
;; (define-extern *jinx-exit-vehicle-speech-index* object)
|
|
;; (define-extern *jinx-board-vehicle-speech-index* object)
|
|
;; (define-extern *jinx-exit-vehicle-speech* array)
|
|
;; (define-extern *jinx-board-vehicle-speech* array)
|
|
;; (define-extern *combox-debris-params* debris-static-params)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prim-beam ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype prim-beam (process-drawable)
|
|
((strip basic :offset-assert 200)
|
|
(pos0 vector :inline :offset-assert 208)
|
|
(pos1 vector :inline :offset-assert 224)
|
|
(appearance prim-beam-settings :inline :offset-assert 240)
|
|
(duration uint64 :offset-assert 272)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x118
|
|
:flag-assert #x1a00a00118
|
|
(:methods
|
|
(prim-beam-method-22 () none) ;; 22
|
|
(prim-beam-method-23 () none) ;; 23
|
|
(prim-beam-method-24 () none) ;; 24
|
|
(prim-beam-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
hidden ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype prim-beam-tracker (prim-beam)
|
|
((track-obj1 uint64 :offset-assert 280)
|
|
(track-obj2 uint64 :offset-assert 288)
|
|
(track-joint1 int32 :offset-assert 296)
|
|
(track-joint2 int32 :offset-assert 300)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x130
|
|
:flag-assert #x1a00b00130
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *default-prim-beam-appearance* object)
|
|
;; (define-extern prim-beam-tracker-init-by-other function)
|
|
;; (define-extern spawn-prim-beam-tracker function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precura-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype precura-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
(generator pulse-state :inline :offset-assert 16)
|
|
(main float :offset-assert 32)
|
|
(target-laser UNKNOWN 2 :offset-assert 36)
|
|
(current-laser UNKNOWN 2 :offset-assert 44)
|
|
(speed-laser float :offset-assert 52)
|
|
(target-bomb float :offset-assert 56)
|
|
(current-bomb float :offset-assert 60)
|
|
(speed-bomb float :offset-assert 64)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x44
|
|
:flag-assert #x900000044
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype precurb-states (structure)
|
|
((pulse pulse-state :inline :offset-assert 0)
|
|
(main float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lprecurc-loader (process)
|
|
((name basic :offset-assert 0)
|
|
(mask process-mask :offset-assert 4)
|
|
(clock basic :offset-assert 8)
|
|
(parent uint32 :offset-assert 12)
|
|
(brother uint32 :offset-assert 16)
|
|
(child uint32 :offset-assert 20)
|
|
(ppointer uint32 :offset-assert 24)
|
|
(self basic :offset-assert 28)
|
|
(pool basic :offset-assert 32)
|
|
(status basic :offset-assert 36)
|
|
(pid int32 :offset-assert 40)
|
|
(main-thread basic :offset-assert 44)
|
|
(top-thread basic :offset-assert 48)
|
|
(entity basic :offset-assert 52)
|
|
(level basic :offset-assert 56)
|
|
(state basic :offset-assert 60)
|
|
(prev-state basic :offset-assert 64)
|
|
(next-state basic :offset-assert 68)
|
|
(state-stack basic :offset-assert 72)
|
|
(trans-hook basic :offset-assert 76)
|
|
(post-hook basic :offset-assert 80)
|
|
(event-hook basic :offset-assert 84)
|
|
(allocated-length int32 :offset-assert 88)
|
|
(heap-base uint32 :offset-assert 92)
|
|
(heap-top uint32 :offset-assert 96)
|
|
(heap-cur uint32 :offset-assert 100)
|
|
(stack-frame-top basic :offset-assert 104)
|
|
(heap kheap :inline :offset-assert 92)
|
|
(connection-list connectable :inline :offset-assert 108)
|
|
(stack UNKNOWN :dynamic :offset-assert 124)
|
|
)
|
|
:method-count-assert 16
|
|
:size-assert #x80
|
|
:flag-assert #x1000000080
|
|
(:state-methods
|
|
idle ;; 14
|
|
die ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern init-mood-precura function)
|
|
;; (define-extern update-precura-lights function)
|
|
;; (define-extern update-mood-precura function)
|
|
;; (define-extern set-precura-generator-light! function)
|
|
;; (define-extern set-precura-laser-light! function)
|
|
;; (define-extern set-precura-bomb-light! function)
|
|
;; (define-extern init-mood-precurb function)
|
|
;; (define-extern update-mood-precurb function)
|
|
;; (define-extern lprecurc-loader-init-by-other function)
|
|
;; (define-extern precura-login function)
|
|
;; (define-extern precura-activate function)
|
|
;; (define-extern precura-deactivate function)
|
|
;; (define-extern precura-logout function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-hud ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; metalhead-flitter ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype metalhead-flitter (mh-squad-member)
|
|
((move-angle float :offset-assert 1080)
|
|
(heading symbol :offset-assert 1084) ;; guessed by decompiler
|
|
(change-dir-time uint64 :offset-assert 1088) ;; time-frame
|
|
(last-change-dir uint64 :offset-assert 1096)
|
|
(off-screen-timer uint64 :offset-assert 1104)
|
|
(amb-sound-timer uint64 :offset-assert 1112)
|
|
(attack-time uint64 :offset-assert 1120) ;; time-frame
|
|
(target-pos vector :inline :offset-assert 1136)
|
|
(attack-pos vector :inline :offset-assert 1152)
|
|
(base-height float :offset-assert 1168)
|
|
)
|
|
:method-count-assert 229
|
|
:size-assert #x494
|
|
:flag-assert #xe504200494
|
|
(:methods
|
|
(metalhead-flitter-method-224 () none) ;; 224
|
|
(metalhead-flitter-method-225 () none) ;; 225
|
|
(metalhead-flitter-method-226 () none) ;; 226
|
|
(metalhead-flitter-method-227 () none) ;; 227
|
|
(metalhead-flitter-method-228 () none) ;; 228
|
|
)
|
|
(:state-methods
|
|
victory ;; 39
|
|
ambush-jumping ;; 223
|
|
ambush ;; 47
|
|
active ;; 34
|
|
stare ;; 37
|
|
attack ;; 222
|
|
hostile ;; 38
|
|
die ;; 40
|
|
circling ;; 157
|
|
in-ditch ;; 192
|
|
die-fast ;; 42
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-mh-flitter-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *metalhead-flitter-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern metalhead-flitter-fall-and-play-death-anim function) ;; (function int float time-frame none :behavior metalhead-flitter)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desertf-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype des-jump-bridge (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
raise ;; 21
|
|
up ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-draw-bridge (process-drawable)
|
|
((plane vector :inline :offset-assert 208)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xe0
|
|
:flag-assert #x1a006000e0
|
|
(:methods
|
|
(des-draw-bridge-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
dormant ;; 21
|
|
lower ;; 22
|
|
down ;; 23
|
|
raise ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype des-garage-door (process-drawable)
|
|
()
|
|
:method-count-assert 24
|
|
:size-assert #xc8
|
|
:flag-assert #x18005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
open ;; 21
|
|
opening ;; 22
|
|
closing ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern des-garage-door-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; comb-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype comb-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern init-mood-comb function)
|
|
;; (define-extern update-mood-comb function)
|
|
;; (define-extern *comb-field-texture-anim-array* texture-anim-array)
|
|
;; (define-extern set-comb-field-color! function)
|
|
;; (define-extern set-comb-field-flash! function)
|
|
;; (define-extern set-comb-field-texture-masks! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyport-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hiphog-exterior-marquee (process-drawable)
|
|
((rot vector :inline :offset-assert 208)
|
|
(master-enable uint32 :offset-assert 224)
|
|
(mode uint32 :offset-assert 240)
|
|
(counter int32 :offset-assert 244)
|
|
(parts sparticle-launch-control 1 :offset-assert 248) ;; guessed by decompiler
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xfc
|
|
:flag-assert #x16008000fc
|
|
(:methods
|
|
(hiphog-exterior-marquee-method-21 () none) ;; 21 ;; (hiphog-exterior-marquee-method-21 (_type_) none 21)
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype farthy (process-drawable)
|
|
((new-trans-hook basic :offset-assert 200)
|
|
(cur-trans-hook basic :offset-assert 204)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xd0
|
|
:flag-assert #x15005000d0
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern check-drop-level-ctyport-drop-userdata function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
;; (define-extern *hiphog-exterior-marquee* array) ;; (array object)
|
|
;; (define-extern ctyport-sparticle-mode-animate function)
|
|
;; (define-extern *hiphog-exterior-marquee-group-ids* array) ;; (array int32)
|
|
;; (define-extern *hiphog-exterior-marquee-daxter-group-ids* array) ;; (array int32)
|
|
;; (define-extern *range-color-rubble-flame* curve-color-fast)
|
|
;; (define-extern *range-alpha-rubble-flame* curve2d-fast)
|
|
;; (define-extern *range-scale-rubble-flame-x* curve2d-fast)
|
|
;; (define-extern *range-scale-rubble-flame-y* curve2d-fast)
|
|
;; (define-extern *r-curve-rubble-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-rubble-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-rubble-flame* curve2d-fast)
|
|
;; (define-extern *curve-alpha-rubble-flame* curve2d-fast)
|
|
;; (define-extern *curve-scale-rubble-flame-x* curve2d-fast)
|
|
;; (define-extern *curve-scale-rubble-flame-y* curve2d-fast)
|
|
;; (define-extern *part-ctyport-rubble-fire-flame-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; comb-sentry ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype comb-sentry-shot (guard-shot)
|
|
()
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype comb-sentry (process-focusable)
|
|
((target-pos vector :inline :offset-assert 208)
|
|
(up-dir vector :inline :offset-assert 224)
|
|
(attack-vel vector :inline :offset-assert 240)
|
|
(exploder-params basic :offset-assert 256)
|
|
(exploder-skel basic :offset-assert 260)
|
|
(exploder-anim uint32 :offset-assert 264)
|
|
(target-dist float :offset-assert 268)
|
|
(path-t float :offset-assert 272)
|
|
(path-dt float :offset-assert 276)
|
|
(hit-points float :offset-assert 280)
|
|
(incoming-attack-id int32 :offset-assert 284)
|
|
(angle float :offset-assert 288)
|
|
(spin float :offset-assert 292)
|
|
(shooting basic :offset-assert 296)
|
|
(should-attack basic :offset-assert 300)
|
|
(i-barrel int8 :offset-assert 304)
|
|
(hum-id uint32 :offset-assert 308)
|
|
(shot-time uint64 :offset-assert 312)
|
|
(attack-time uint64 :offset-assert 320)
|
|
(in-range-time uint64 :offset-assert 328)
|
|
(player-vehicle uint64 :offset-assert 336)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x158
|
|
:flag-assert #x2800e00158
|
|
(:methods
|
|
(comb-sentry-method-31 () none) ;; 31
|
|
(comb-sentry-method-32 () none) ;; 32
|
|
(comb-sentry-method-33 () none) ;; 33
|
|
(comb-sentry-method-34 () none) ;; 34
|
|
(comb-sentry-method-35 () none) ;; 35
|
|
(comb-sentry-method-36 () none) ;; 36
|
|
(comb-sentry-method-37 () none) ;; 37
|
|
(comb-sentry-method-38 () none) ;; 38
|
|
(comb-sentry-method-39 () none) ;; 39
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
path-follow ;; 29
|
|
explode ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype comb-sentinel (comb-sentry)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x158
|
|
:flag-assert #x2800e00158
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rail-sentinel (comb-sentry)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x158
|
|
:flag-assert #x2800e00158
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *comb-sentry-explode-params* joint-exploder-static-params)
|
|
;; (define-extern *comb-sentry-glow-template* object)
|
|
;; (define-extern *comb-sentry-glow-ring-template* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; comb-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern comb-lightjak-do-effect function)
|
|
;; (define-extern death-precursor death-info) ;; death-info
|
|
;; (define-extern start-precursor-effect function) ;; (function manipy none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; h-sled ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-sled-health (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype pre-sled (process-drawable)
|
|
()
|
|
:method-count-assert 20
|
|
:size-assert #xc8
|
|
:flag-assert #x14005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype sled-shot (projectile)
|
|
((tail-pos vector :inline :offset-assert 512)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x210
|
|
:flag-assert #x2901900210
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-sled-probe-work (structure)
|
|
((local-pos vector :inline :offset-assert 0)
|
|
(local-normal vector :inline :offset-assert 16)
|
|
(world-pos vector :inline :offset-assert 32)
|
|
(world-normal vector :inline :offset-assert 48)
|
|
(probe-pos vector :inline :offset-assert 64)
|
|
(ground-pos vector :inline :offset-assert 80)
|
|
(ground-normal vector :inline :offset-assert 96)
|
|
(velocity vector :inline :offset-assert 112)
|
|
(u-dir vector :inline :offset-assert 128)
|
|
(probe-uu float :offset-assert 144)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x94
|
|
:flag-assert #x900000094
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-sled-physics-work (structure)
|
|
((mat matrix :inline :offset-assert 0)
|
|
(force vector :inline :offset-assert 64)
|
|
(velocity vector :inline :offset-assert 80)
|
|
(world-pos vector :inline :offset-assert 96)
|
|
(world-normal vector :inline :offset-assert 112)
|
|
(local-pos vector :inline :offset-assert 128)
|
|
(steering-axis vector :inline :offset-assert 144)
|
|
(lift-dir vector :inline :offset-assert 160)
|
|
(normal vector :inline :offset-assert 176)
|
|
(tmp vector :inline :offset-assert 192)
|
|
(p-body vector :inline :offset-assert 208)
|
|
(axis vector :inline :offset-assert 224)
|
|
(dir vector :inline :offset-assert 240)
|
|
(ground-normal vector :inline :offset-assert 256)
|
|
(edges UNKNOWN 3 :offset-assert 272)
|
|
(edge-dirs UNKNOWN 3 :offset-assert 320)
|
|
(impulse float :offset-assert 368)
|
|
(vel-dot-norm float :offset-assert 372)
|
|
(friction-coef float :offset-assert 376)
|
|
(speed-factor float :offset-assert 380)
|
|
(best-len float :offset-assert 384)
|
|
(len float :offset-assert 388)
|
|
(i-longest int8 :offset-assert 392)
|
|
(probe-work-array UNKNOWN 4 :offset-assert 400)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x410
|
|
:flag-assert #x900000410
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-sled (vehicle)
|
|
((health-hud uint64 :offset-assert 696)
|
|
(overturned-time uint64 :offset-assert 704)
|
|
(shoot-time uint64 :offset-assert 712)
|
|
(shoot-delay uint16 :offset-assert 720)
|
|
(rider-hand-joint-array UNKNOWN 2 :offset-assert 722)
|
|
(i-barrel int8 :offset-assert 724)
|
|
(ai-target-speed float :offset-assert 728)
|
|
(engine-thrust float :offset-assert 732)
|
|
(engine-sound-envelope float :offset-assert 736)
|
|
(engine-sound-id uint32 :offset-assert 740)
|
|
(steer-sound-id uint32 :offset-assert 744)
|
|
(turbo-sound-id uint32 :offset-assert 748)
|
|
(engine-sound-envelope float :offset-assert 736)
|
|
(in-tunnel basic :offset-assert 756)
|
|
(whoosh-time uint64 :offset-assert 760)
|
|
(parts UNKNOWN 4 :offset-assert 768)
|
|
(gravity-dir vector :inline :offset-assert 784)
|
|
(path-pos vector :inline :offset-assert 800)
|
|
(path-dir vector :inline :offset-assert 816)
|
|
(tunnel-dir vector :inline :offset-assert 832)
|
|
(prev-tunnel-dir vector :inline :offset-assert 848)
|
|
(sum-ground-normal vector :inline :offset-assert 864)
|
|
(normal-dir vector :inline :offset-assert 880)
|
|
(impact-normal vector :inline :offset-assert 896)
|
|
(side-dir vector :inline :offset-assert 912)
|
|
(ai-target-pos vector :inline :offset-assert 928)
|
|
(whoosh-pos vector :inline :offset-assert 944)
|
|
(ground-pos-array UNKNOWN 4 :offset-assert 960)
|
|
)
|
|
:method-count-assert 153
|
|
:size-assert #x400
|
|
:flag-assert #x9903800400
|
|
(:methods
|
|
(h-sled-method-152 () none) ;; 152
|
|
)
|
|
(:state-methods
|
|
explode ;; 60
|
|
player-control ;; 58
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern hud-sled-health-spawn function)
|
|
;; (define-extern sled-find-mesh-dir function)
|
|
;; (define-extern sled-shot-move function)
|
|
;; (define-extern sled-shot-reaction function)
|
|
;; (define-extern *h-sled-explosion-info* vehicle-explosion-info)
|
|
;; (define-extern *h-sled-constants* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-dust-storm ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype desert-dust-storm (process)
|
|
((intensity float :offset-assert 128)
|
|
(intensity-rate float :offset-assert 132)
|
|
(intensity-target float :offset-assert 136)
|
|
(origin vector :inline :offset-assert 144)
|
|
(current-wind-angle-speed float :offset-assert 160)
|
|
(current-wind-angle float :offset-assert 164)
|
|
(dest-wind-angle float :offset-assert 168)
|
|
(wind-speed float :offset-assert 172)
|
|
(dest-wind-speed float :offset-assert 176)
|
|
(stretch-val float :offset-assert 180)
|
|
(last-hold-time uint64 :offset-assert 184)
|
|
(wind-intensity float :offset-assert 192)
|
|
(new-generate-time uint64 :offset-assert 200)
|
|
(state-time uint64 :offset-assert 208)
|
|
(fog-plane-origin vector :inline :offset-assert 224)
|
|
(fog-plane-dir vector :inline :offset-assert 240)
|
|
(is-intro? basic :offset-assert 256)
|
|
(wind-sound uint32 :offset-assert 260)
|
|
(enabled-screen-filter? basic :offset-assert 264)
|
|
(dust-storm-clock-scalar float :offset-assert 268)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x110
|
|
:flag-assert #x1500900110
|
|
(:methods
|
|
(desert-dust-storm-method-17 () none) ;; 17
|
|
(desert-dust-storm-method-18 () none) ;; 18
|
|
(desert-dust-storm-method-19 () none) ;; 19
|
|
(desert-dust-storm-method-20 () none) ;; 20
|
|
)
|
|
(:state-methods
|
|
track ;; 14
|
|
hold-pos ;; 15
|
|
die ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dust-storm-bank (basic)
|
|
((spawn-radius meters :offset-assert 4)
|
|
(spawn-rand-xz-min meters :offset-assert 8)
|
|
(spawn-rand-xz-max meters :offset-assert 12)
|
|
(spawn-rand-y-min meters :offset-assert 16)
|
|
(spawn-rand-y-max meters :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *duststorm-wind-vec* object)
|
|
;; (define-extern *duststorm-wind-vel* object)
|
|
;; (define-extern *duststorm-intensity* object)
|
|
;; (define-extern *duststorm-stationary?* object)
|
|
;; (define-extern *fog-intensity-scalar* object)
|
|
;; (define-extern desert-dust-storm-init-by-other function)
|
|
;; (define-extern *DUST_STORM-bank* dust-storm-bank)
|
|
;; (define-extern sparticle-duststorm-birth-func function)
|
|
;; (define-extern sparticle-duststorm-move function)
|
|
;; (define-extern compute-wind-angle function)
|
|
;; (define-extern create-dust-storm function)
|
|
;; (define-extern desert-activate function)
|
|
;; (define-extern desert-deactivate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; credits ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lfaccar-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern lfaccar-activate function)
|
|
;; (define-extern lfaccar-deactivate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; onintent-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern check-bubble-surface-onintent function) ;; (function sparticle-system sparticle-cpuinfo matrix symbol)
|
|
;; (define-extern check-onintent-bugs function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; stadium-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype stadium-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(flame flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-mood-stadium function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; stadium-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasstad-ocean ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ocean-colors-wasstad* object)
|
|
;; (define-extern *ocean-near-indices-wasstad* ocean-near-indices)
|
|
;; (define-extern *ocean-trans-indices-wasstad* ocean-trans-indices)
|
|
;; (define-extern *ocean-mid-indices-wasstad* ocean-mid-indices)
|
|
;; (define-extern *ocean-mid-masks-wasstad* ocean-mid-masks)
|
|
;; (define-extern *ocean-map-wasstad* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasstada-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *wasstada-alpha-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasstada-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype wasstada-states (structure)
|
|
((flame0 flames-state :inline :offset-assert 0)
|
|
(flame1 flames-state :inline :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xf
|
|
:flag-assert #x90000000f
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *wasstada-mood-color-table* object)
|
|
;; (define-extern *wasstada-mood-fog-table* object)
|
|
;; (define-extern update-mood-wasstada function)
|
|
;; (define-extern update-mood-copy-wasstada function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factorya-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *factoryb-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; stadium-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-birth-func-brightness-buggy-door function)
|
|
;; (define-extern spt-birth-func-part-buggy-door function)
|
|
;; (define-extern *range-sat-explo-fma-color* curve-color-fast)
|
|
;; (define-extern *range-sat-explo-fma-alpha* curve2d-fast)
|
|
;; (define-extern *range-sat-explo-fma-scale-x* curve2d-fast)
|
|
;; (define-extern *range-sat-explo-fma-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-fma-alpha* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-fma-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-sat-explo-fma-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fma-neo-satellite-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factoryb-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern factoryb-activate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mhcitya-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *lmhcitya-tfrag-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *mhcitya-pris-texture-anim-array* texture-anim-array)
|
|
;; (define-extern set-mhcity-de-door-skin! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctyinda-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ctyinda-steam-particle-list* array)
|
|
;; (define-extern birth-func-texture-group-steam-ctyinda function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctywide-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-birth-func-brightness-part-fma-dark-eco-steam function)
|
|
;; (define-extern *range-fma-city-barrier-explo-big-color* curve-color-fast)
|
|
;; (define-extern *range-fma-city-barrier-explo-big-alpha* curve2d-fast)
|
|
;; (define-extern *range-fma-city-barrier-explo-big-scale-x* curve2d-fast)
|
|
;; (define-extern *range-fma-city-barrier-explo-big-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-fma-city-barrier-explo-big-alpha* curve2d-fast)
|
|
;; (define-extern *curve-fma-city-barrier-explo-big-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-fma-city-barrier-explo-big-scale-y* curve2d-fast)
|
|
;; (define-extern *part-fma-city-barrier-explosion-big-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kanga-lizard ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype waschase-speech-instance (structure)
|
|
((speech uint16 :offset-assert 0)
|
|
(probability float :offset-assert 4)
|
|
(flags uint64 :offset-assert 8)
|
|
(play-count uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype waschase-speech-info (structure)
|
|
((speeches basic :offset-assert 0)
|
|
(play-time uint64 :offset-assert 8)
|
|
(current-random uint64 :offset-assert 16)
|
|
(minimum-interval uint64 :offset-assert 24)
|
|
(random-interval uint64 :offset-assert 32)
|
|
(last-played int8 :offset-assert 40)
|
|
(flags uint8 :offset-assert 41)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2a
|
|
:flag-assert #x90000002a
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype waschase-speech-group (structure)
|
|
((play-time uint64 :offset-assert 0)
|
|
(info basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kanga-lizard (nav-enemy)
|
|
((minimap connection-minimap :offset-assert 620)
|
|
(last-focus-ping uint64 :offset-assert 624)
|
|
(total-flee-time uint64 :offset-assert 632)
|
|
(current-flee-start uint64 :offset-assert 640)
|
|
(being-attacked basic :offset-assert 648)
|
|
)
|
|
:method-count-assert 193
|
|
:size-assert #x28c
|
|
:flag-assert #xc10210028c
|
|
(:state-methods
|
|
flee ;; 36
|
|
reinit-if-find-nav-mesh ;; 191
|
|
knocked ;; 31
|
|
hidden ;; 190
|
|
die-eaten ;; 192
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-kanga-lizard (task-manager)
|
|
((manager-entity basic :offset-assert 236)
|
|
(check-timer uint64 :offset-assert 244)
|
|
(main-timer uint64 :offset-assert 252)
|
|
(actor-group uint32 :offset-assert 260)
|
|
(actor-group-count int32 :offset-assert 264)
|
|
(dead-mask uint32 :offset-assert 268)
|
|
(last-eaten-talk int8 :offset-assert 272)
|
|
(last-die-talk int8 :offset-assert 273)
|
|
(been-on-flut basic :offset-assert 276)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x11c
|
|
:flag-assert #x2100a0011c
|
|
(:methods
|
|
(task-manager-kanga-lizard-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *kanga-lizard-speech-list* object)
|
|
;; (define-extern *waschase-speech* object)
|
|
;; (define-extern reset-waschase-speeches function)
|
|
;; (define-extern waschase-play-speech function)
|
|
;; (define-extern *kanga-lizard-nav-enemy-info* nav-enemy-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; kg-squad-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *default-kg-squad-member-settings* object)
|
|
;; (define-extern *alert-kg-squad-member-settings* object)
|
|
;; (define-extern *war-kg-squad-member-settings* object)
|
|
;; (define-extern set-kg-primary-target function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hover-nav-lpattack ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *lpattack-adjacency* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rubble-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *rubblea-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *rubblea2-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *rubbleb-water-texture-anim-array* texture-anim-array)
|
|
;; (define-extern *rubblec-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; stadiuma-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-birth-func-brightness-part-rubble-break-dust function)
|
|
;; (define-extern spt-birth-func-brightness-part-rubble-break-dust-trail function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fac-edge-list (basic)
|
|
((edge UNKNOWN 4 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-inout (structure)
|
|
((lpath int16 :offset-assert 0)
|
|
(lpos float :offset-assert 4)
|
|
(flags uint8 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x9
|
|
:flag-assert #x900000009
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-pathlist (structure)
|
|
((path UNKNOWN 200 :offset-assert 0)
|
|
(inout UNKNOWN 200 :offset-assert 800)
|
|
(loops UNKNOWN 200 :offset-assert 4000)
|
|
(npath int8 :offset-assert 4400)
|
|
(nloop int8 :offset-assert 4401)
|
|
(curidx int8 :offset-assert 4402)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x1133
|
|
:flag-assert #x900001133
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-manager (process)
|
|
((nfighters-spawned uint8 :offset-assert 128)
|
|
(nfighters-total uint8 :offset-assert 129)
|
|
(ntanks-spawned uint8 :offset-assert 130)
|
|
(player-born uint64 :offset-assert 136)
|
|
(player-died uint64 :offset-assert 144)
|
|
(fighter-spawned uint64 :offset-assert 152)
|
|
(fighter-killed uint64 :offset-assert 160)
|
|
(tank-spawned uint64 :offset-assert 168)
|
|
(tank-killed uint64 :offset-assert 176)
|
|
(fpath factory-pathlist :inline :offset-assert 184)
|
|
(tpath factory-pathlist :inline :offset-assert 4588)
|
|
(cur-wave uint8 :offset-assert 8991)
|
|
)
|
|
:method-count-assert 17
|
|
:size-assert #x2320
|
|
:flag-assert #x1122a02320
|
|
(:methods
|
|
(factory-manager-method-14 () none) ;; 14
|
|
(factory-manager-method-15 () none) ;; 15
|
|
(factory-manager-method-16 () none) ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-fighter (rigid-body-object)
|
|
((first-time? basic :offset-assert 288)
|
|
(path-pos float :offset-assert 292)
|
|
(forw vector :inline :offset-assert 304)
|
|
(upvc vector :inline :offset-assert 320)
|
|
(ppos vector :inline :offset-assert 336)
|
|
(pvel vector :inline :offset-assert 352)
|
|
(pacc vector :inline :offset-assert 368)
|
|
(blendpath float :offset-assert 384)
|
|
(newpath int8 :offset-assert 388)
|
|
(path-idx int8 :offset-assert 389)
|
|
(last-hit-time uint64 :offset-assert 392)
|
|
(disappear basic :offset-assert 400)
|
|
(last-fire uint64 :offset-assert 408)
|
|
(turret-gun int8 :offset-assert 416)
|
|
(light-trail uint64 :offset-assert 424)
|
|
(rot-vel float :offset-assert 432)
|
|
(rot-acc float :offset-assert 436)
|
|
(engine-sound uint32 :offset-assert 440)
|
|
(engine-sound-playing? basic :offset-assert 444)
|
|
(last-snd-cmd uint64 :offset-assert 448)
|
|
(red-tip-change-time uint64 :offset-assert 456)
|
|
(red-tip-on basic :offset-assert 464)
|
|
)
|
|
:method-count-assert 63
|
|
:size-assert #x1d4
|
|
:flag-assert #x3f016001d4
|
|
(:methods
|
|
(factory-fighter-method-56 () none) ;; 56
|
|
(factory-fighter-method-57 () none) ;; 57
|
|
(factory-fighter-method-58 () none) ;; 58
|
|
(factory-fighter-method-59 () none) ;; 59
|
|
(factory-fighter-method-60 () none) ;; 60
|
|
(factory-fighter-method-61 () none) ;; 61
|
|
(factory-fighter-method-62 () none) ;; 62
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-target (process-focusable)
|
|
((sync sync-paused :inline :offset-assert 208)
|
|
(minimap connection-minimap :offset-assert 232)
|
|
(light-jm basic :offset-assert 236)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #xf0
|
|
:flag-assert #x23007000f0
|
|
(:methods
|
|
(fac-target-method-28 () none) ;; 28
|
|
(fac-target-method-29 () none) ;; 29
|
|
(fac-target-method-30 () none) ;; 30
|
|
(fac-target-method-31 () none) ;; 31
|
|
(fac-target-method-32 () none) ;; 32
|
|
(fac-target-method-33 () none) ;; 33
|
|
(fac-target-method-34 () none) ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-gun-tower (process-focusable)
|
|
((yaw float :offset-assert 208)
|
|
(yawvel float :offset-assert 212)
|
|
(pitch float :offset-assert 216)
|
|
(pitchvel float :offset-assert 220)
|
|
(dyaw float :offset-assert 224)
|
|
(dpitch float :offset-assert 228)
|
|
(last-fire uint64 :offset-assert 232)
|
|
(last-hit-time uint64 :offset-assert 240)
|
|
(gunrot int8 :offset-assert 248)
|
|
(muzzle int8 :offset-assert 249)
|
|
(gun-idx int8 :offset-assert 250)
|
|
(attack-id int32 :offset-assert 252)
|
|
(gun-tilt-jm basic :offset-assert 256)
|
|
(hit-points float :offset-assert 260)
|
|
(invincable basic :offset-assert 264)
|
|
(rotate-sound uint32 :offset-assert 268)
|
|
(rotate-sound-playing basic :offset-assert 272)
|
|
(blade-sound uint32 :offset-assert 276)
|
|
(blade-sound-playing basic :offset-assert 280)
|
|
(snd-cmd-time uint64 :offset-assert 288)
|
|
(minimap connection-minimap :offset-assert 296)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x12c
|
|
:flag-assert #x2600b0012c
|
|
(:methods
|
|
(fac-gun-tower-method-28 () none) ;; 28
|
|
(fac-gun-tower-method-29 () none) ;; 29
|
|
(fac-gun-tower-method-30 () none) ;; 30
|
|
(fac-gun-tower-method-31 () none) ;; 31
|
|
(fac-gun-tower-method-32 () none) ;; 32
|
|
(fac-gun-tower-method-33 () none) ;; 33
|
|
(fac-gun-tower-method-34 () none) ;; 34
|
|
(fac-gun-tower-method-35 () none) ;; 35
|
|
(fac-gun-tower-method-36 () none) ;; 36
|
|
(fac-gun-tower-method-37 () none) ;; 37
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-gun-tower-break (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:methods
|
|
(fac-gun-tower-break-method-20 () none) ;; 20
|
|
(fac-gun-tower-break-method-21 () none) ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-gun-tower-base-broken (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:methods
|
|
(fac-gun-tower-base-broken-method-20 () none) ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-factory-damage (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rubble-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rub-tower (process-focusable)
|
|
((last-attack-time uint64 :offset-assert 208)
|
|
(collision-updated? basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #xdc
|
|
:flag-assert #x23006000dc
|
|
(:methods
|
|
(rub-tower-method-32 () none) ;; 32
|
|
(rub-tower-method-33 () none) ;; 33
|
|
(rub-tower-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
unstable ;; 29
|
|
fall ;; 30
|
|
fallen ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-electric-gate-switch (process-focusable)
|
|
((part-sparks basic :offset-assert 208)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #xd4
|
|
:flag-assert #x23006000d4
|
|
(:methods
|
|
(rub-electric-gate-switch-method-31 () none) ;; 31
|
|
(rub-electric-gate-switch-method-32 () none) ;; 32
|
|
(rub-electric-gate-switch-method-33 () none) ;; 33
|
|
(rub-electric-gate-switch-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
explode ;; 29
|
|
exploded ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-elec-gate (process-drawable)
|
|
((path-l basic :offset-assert 148)
|
|
(path-r basic :offset-assert 196)
|
|
(actor-group uint32 :offset-assert 200)
|
|
(actor-group-count int32 :offset-assert 204)
|
|
(width float :offset-assert 208)
|
|
(height float :offset-assert 212)
|
|
(active? basic :offset-assert 216)
|
|
(switch-status uint8 :offset-assert 220)
|
|
(palette-id int8 :offset-assert 221)
|
|
(hit-sound-id uint32 :offset-assert 224)
|
|
(shutoff-delay-time uint64 :offset-assert 228)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xf0
|
|
:flag-assert #x17007000f0
|
|
(:methods
|
|
(rub-elec-gate-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-electric-gate-panel (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:methods
|
|
(rub-electric-gate-panel-method-21 () none) ;; 21
|
|
(rub-electric-gate-panel-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-electric-gate-panel-a (rub-electric-gate-panel)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-electric-gate-panel-b (rub-electric-gate-panel)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-electric-gate-panel-c (rub-electric-gate-panel)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rub-electric-gate-panel-d (rub-electric-gate-panel)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
)
|
|
|#
|
|
|
|
;; (define-extern rub-tower-event-handler function)
|
|
;; (define-extern *rub-electric-gate-switch-exploder-params* joint-exploder-static-params)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; rapid-gunner ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype rapid-gunner (nav-enemy)
|
|
((dest-quat quaternion :inline :offset-assert 624)
|
|
(turret-pos vector :inline :offset-assert 640)
|
|
(turret-actor basic :offset-assert 656)
|
|
(scared-timer uint64 :offset-assert 664)
|
|
)
|
|
:method-count-assert 197
|
|
:size-assert #x2a0
|
|
:flag-assert #xc5022002a0
|
|
(:state-methods
|
|
hostile ;; 38
|
|
turret-seek ;; 190
|
|
turret-get-on ;; 191
|
|
turret-active ;; 192
|
|
turret-active-shoot ;; 193
|
|
turret-getting-off ;; 194
|
|
turret-get-off ;; 195
|
|
attack ;; 196
|
|
knocked-recover ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *rapid-gunner-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
;; (define-extern rapid-gunner-turret-post function)
|
|
;; (define-extern rapid-gunner-turret-code function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasstadc-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-throne-rog (task-manager)
|
|
((arrow-h uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf8
|
|
:flag-assert #x20008000f8
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-fight-plat-box (base-plat)
|
|
((crate-h uint64 :offset-assert 272)
|
|
(next-lava-part uint64 :offset-assert 280)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x120
|
|
:flag-assert #x2900a00120
|
|
(:methods
|
|
(wstd-fight-plat-box-method-37 () none) ;; 37
|
|
(wstd-fight-plat-box-method-38 () none) ;; 38
|
|
(wstd-fight-plat-box-method-39 () none) ;; 39
|
|
(wstd-fight-plat-box-method-40 () none) ;; 40
|
|
)
|
|
(:state-methods
|
|
open ;; 36
|
|
active ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-fight-house-a (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
open ;; 21
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-fight-plat (base-plat)
|
|
((basepos vector :inline :offset-assert 272)
|
|
(box UNKNOWN 4 :offset-assert 288)
|
|
(door UNKNOWN 4 :offset-assert 320)
|
|
(next-crate-spawn uint64 :offset-assert 352)
|
|
(next-box-spawn int32 :offset-assert 360)
|
|
(delta-y float :offset-assert 364)
|
|
(spawn-lava? basic :offset-assert 368)
|
|
(next-lava-part uint64 :offset-assert 376)
|
|
(part-lava-pos vector :inline :offset-assert 384)
|
|
(attack-pos UNKNOWN 8 :offset-assert 400)
|
|
(attack-ang UNKNOWN 8 :offset-assert 528)
|
|
(cur-point int32 :offset-assert 560)
|
|
(ambient-sound-id uint32 :offset-assert 564)
|
|
(depth float :offset-assert 568)
|
|
(go-up basic :offset-assert 572)
|
|
(translate float :offset-assert 576)
|
|
(next-lava-sound uint64 :offset-assert 584)
|
|
(next-alarm-sound uint64 :offset-assert 592)
|
|
(y-offset-box float :offset-assert 600)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x25c
|
|
:flag-assert #x2901e0025c
|
|
(:methods
|
|
(wstd-fight-plat-method-36 () none) ;; 36
|
|
(wstd-fight-plat-method-39 () none) ;; 39
|
|
(wstd-fight-plat-method-40 () none) ;; 40
|
|
)
|
|
(:state-methods
|
|
plat-base-state ;; 35
|
|
active ;; 37
|
|
go-down ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-fight-plat-smlplat (base-plat)
|
|
((basepos vector :inline :offset-assert 272)
|
|
(box uint64 :offset-assert 288)
|
|
(next-crate-spawn uint64 :offset-assert 296)
|
|
(next-box-spawn int32 :offset-assert 304)
|
|
(delta-y float :offset-assert 308)
|
|
(spawn-lava? basic :offset-assert 312)
|
|
(next-lava-part uint64 :offset-assert 320)
|
|
(part-lava-pos vector :inline :offset-assert 336)
|
|
(ambient-sound-id uint32 :offset-assert 352)
|
|
(depth float :offset-assert 356)
|
|
(translate float :offset-assert 360)
|
|
(angle-move float :offset-assert 364)
|
|
(ride-timer uint64 :offset-assert 368)
|
|
(lock basic :offset-assert 376)
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x17c
|
|
:flag-assert #x2b0100017c
|
|
(:methods
|
|
(wstd-fight-plat-smlplat-method-36 () none) ;; 36
|
|
(wstd-fight-plat-smlplat-method-41 () none) ;; 41
|
|
(wstd-fight-plat-smlplat-method-42 () none) ;; 42
|
|
)
|
|
(:state-methods
|
|
plat-base-state ;; 35
|
|
active ;; 37
|
|
go-down ;; 38
|
|
go-up ;; 39
|
|
go-up-fma ;; 40
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-fight-plat-large (base-plat)
|
|
((basepos vector :inline :offset-assert 272)
|
|
(box UNKNOWN 4 :offset-assert 288)
|
|
(door UNKNOWN 8 :offset-assert 320)
|
|
(next-crate-spawn uint64 :offset-assert 384)
|
|
(next-box-spawn int32 :offset-assert 392)
|
|
(delta-y float :offset-assert 396)
|
|
(spawn-lava? basic :offset-assert 400)
|
|
(next-lava-part uint64 :offset-assert 408)
|
|
(part-lava-pos vector :inline :offset-assert 416)
|
|
(attack-pos UNKNOWN 8 :offset-assert 432)
|
|
(attack-ang UNKNOWN 8 :offset-assert 560)
|
|
(cur-point int32 :offset-assert 592)
|
|
(ambient-sound-id uint32 :offset-assert 596)
|
|
(depth float :offset-assert 600)
|
|
(go-up basic :offset-assert 604)
|
|
(translate float :offset-assert 608)
|
|
(next-lava-sound uint64 :offset-assert 616)
|
|
(next-alarm-sound uint64 :offset-assert 624)
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x278
|
|
:flag-assert #x2b02000278
|
|
(:methods
|
|
(wstd-fight-plat-large-method-36 () none) ;; 36
|
|
(wstd-fight-plat-large-method-40 () none) ;; 40
|
|
(wstd-fight-plat-large-method-41 () none) ;; 41
|
|
(wstd-fight-plat-large-method-42 () none) ;; 42
|
|
)
|
|
(:state-methods
|
|
plat-base-state ;; 35
|
|
active ;; 37
|
|
go-down ;; 38
|
|
end ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype house-info (structure)
|
|
((joint-index uint32 :offset-assert 0)
|
|
(y-angle float :offset-assert 4)
|
|
(x-offset float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype marauder-info (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(vis-point int32 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-arena-fight-base (task-manager)
|
|
((marauder UNKNOWN 16 :offset-assert 236)
|
|
(last-count uint32 :offset-assert 492)
|
|
(count-alive uint32 :offset-assert 496)
|
|
(entity basic :offset-assert 52)
|
|
(check-timer uint64 :offset-assert 508)
|
|
(next-spawn uint64 :offset-assert 516)
|
|
(count uint32 :offset-assert 524)
|
|
(angle uint32 :offset-assert 528)
|
|
(dark basic :offset-assert 532)
|
|
(arrow-h uint64 :offset-assert 540)
|
|
(snd-id uint32 :offset-assert 548)
|
|
(crowd-intensity float :offset-assert 552)
|
|
(next-go-down uint64 :offset-assert 556)
|
|
(actor-group uint32 :offset-assert 564)
|
|
(actor-group-count int32 :offset-assert 568)
|
|
(platform UNKNOWN 4 :offset-assert 572)
|
|
(gui-id uint32 :offset-assert 604)
|
|
(crate-h UNKNOWN 3 :offset-assert 612)
|
|
(darkbomb basic :offset-assert 636)
|
|
)
|
|
:method-count-assert 37
|
|
:size-assert #x284
|
|
:flag-assert #x2502100284
|
|
(:methods
|
|
(task-manager-arena-fight-base-method-32 () none) ;; 32
|
|
(task-manager-arena-fight-base-method-33 () none) ;; 33
|
|
(task-manager-arena-fight-base-method-34 () none) ;; 34
|
|
(task-manager-arena-fight-base-method-35 () none) ;; 35
|
|
(task-manager-arena-fight-base-method-36 () none) ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-arena-gun-training (task-manager)
|
|
((gui-id uint32 :offset-assert 240)
|
|
(text-id uint32 :offset-assert 244)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xf8
|
|
:flag-assert #x21008000f8
|
|
(:methods
|
|
(task-manager-arena-gun-training-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-arena-gun-training-blue (task-manager-arena-gun-training)
|
|
()
|
|
:method-count-assert 33
|
|
:size-assert #x100
|
|
:flag-assert #x2100800100
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-arena-fight (task-manager-arena-fight-base)
|
|
((display-fire basic :offset-assert 644)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x288
|
|
:flag-assert #x2802100288
|
|
(:methods
|
|
(task-manager-arena-fight-method-39 () none) ;; 39
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
go-down ;; 37
|
|
throne ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-arena-fight-2 (task-manager-arena-fight-base)
|
|
((play-hint basic :offset-assert 644)
|
|
(hint-time uint64 :offset-assert 648)
|
|
(dj-train-time uint64 :offset-assert 656)
|
|
(dj-train uint32 :offset-assert 664)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x29c
|
|
:flag-assert #x280220029c
|
|
(:state-methods
|
|
active ;; 15
|
|
wait-start ;; 39
|
|
go-down ;; 37
|
|
done ;; 38
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-arena-fight-3 (task-manager-arena-fight-2)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x29c
|
|
:flag-assert #x280220029c
|
|
(:state-methods
|
|
done ;; 38
|
|
wait-start ;; 39
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern wstd-fight-plat-box-init-by-other function)
|
|
;; (define-extern wstd-fight-house-a-init-by-other function)
|
|
;; (define-extern *fight-plat-lava-pos* array)
|
|
;; (define-extern wstd-fight-plat-init-by-other function)
|
|
;; (define-extern wstd-fight-plat-smlplat-init-by-other function)
|
|
;; (define-extern wasstadc-tl function)
|
|
;; (define-extern wstd-fight-plat-large-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-ladder ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ladder-info (basic)
|
|
((ladder uint64 :offset-assert 8)
|
|
(flip deg :offset-assert 16)
|
|
(interp float :offset-assert 20)
|
|
(start-mat matrix :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x60
|
|
:flag-assert #x900000060
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *ladder-mods* object)
|
|
;; (define-extern target-ladder-start object)
|
|
;; (define-extern target-ladder-stance object)
|
|
;; (define-extern target-ladder-walk-up object)
|
|
;; (define-extern target-ladder-walk-down object)
|
|
;; (define-extern target-ladder-slide-down object)
|
|
;; (define-extern target-ladder-switch object)
|
|
;; (define-extern target-ladder-jump-off object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ladder ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ladder (process-drawable)
|
|
((rider-unit float :offset-assert 200)
|
|
(rider-time uint64 :offset-assert 208)
|
|
(art-height meters :offset-assert 216)
|
|
(set-height meters :offset-assert 220)
|
|
(meters-per-unit meters :offset-assert 224)
|
|
(meters-per-rung meters :offset-assert 228)
|
|
(options uint32 :offset-assert 232)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xec
|
|
:flag-assert #x1b007000ec
|
|
(:methods
|
|
(ladder-method-22 () none) ;; 22
|
|
(ladder-method-23 () none) ;; 23
|
|
(ladder-method-24 () none) ;; 24
|
|
(ladder-method-25 () none) ;; 25
|
|
(ladder-method-26 () none) ;; 26
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factory-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-factory-sky-battle (task-manager)
|
|
((factory-sky-battle-entity basic :offset-assert 236)
|
|
(check-timer uint64 :offset-assert 244)
|
|
(ended-timer uint64 :offset-assert 252)
|
|
(mission-complete-time uint64 :offset-assert 260)
|
|
(actor-group uint32 :offset-assert 268)
|
|
(actor-group-count int32 :offset-assert 272)
|
|
(cur-group int8 :offset-assert 276)
|
|
(hud-delay uint64 :offset-assert 284)
|
|
(sound-id uint32 :offset-assert 292)
|
|
(hud-damage uint64 :offset-assert 300)
|
|
(hint-given basic :offset-assert 308)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x13c
|
|
:flag-assert #x2100c0013c
|
|
(:methods
|
|
(task-manager-factory-sky-battle-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
resolution ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype light-trail-tracker-vehicle (light-trail-tracker)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xac
|
|
:flag-assert #x15003000ac
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-fighter-path (process-drawable)
|
|
()
|
|
:method-count-assert 20
|
|
:size-assert #xc8
|
|
:flag-assert #x14005000c8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype factory-tanks-path (process-drawable)
|
|
()
|
|
:method-count-assert 20
|
|
:size-assert #xc8
|
|
:flag-assert #x14005000c8
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fac-task-manager* object)
|
|
;; (define-extern *fac-fighter-fired* object)
|
|
;; (define-extern *fac-wave* object)
|
|
;; (define-extern *fac-shotsleft* object)
|
|
;; (define-extern *factory-fighter-trail* object)
|
|
;; (define-extern fac-count-curves function)
|
|
;; (define-extern *fac-tmp-str* object)
|
|
;; (define-extern factory-manager-init-by-other function)
|
|
;; (define-extern factory-manager-start function)
|
|
;; (define-extern *fac-fighter-rigid-body-constants* object)
|
|
;; (define-extern *fac-fighter-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern fighter-best-birth-path function)
|
|
;; (define-extern fighter-birth-path function)
|
|
;; (define-extern factory-fighter-standard-event-handler function)
|
|
;; (define-extern factory-fighter-init-by-other function)
|
|
;; (define-extern factory-fighter-spawn function)
|
|
;; (define-extern *fac-target-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern hack-wave function)
|
|
;; (define-extern fac-target-standard-event-handler function)
|
|
;; (define-extern factory-shotsleft function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-sniper-battery ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cty-sniper-button-top (process-drawable)
|
|
((is-up basic :offset-assert 200)
|
|
(colormode uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd8
|
|
:flag-assert #x17006000d8
|
|
(:state-methods
|
|
idle ;; 20
|
|
going-up ;; 21
|
|
going-down ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-sniper-button (process-drawable)
|
|
((stay-down-time uint64 :offset-assert 200)
|
|
(lid uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xd8
|
|
:flag-assert #x1a006000d8
|
|
(:methods
|
|
(cty-sniper-button-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle-up ;; 20
|
|
going-down ;; 21
|
|
idle-down ;; 22
|
|
bail-up ;; 23
|
|
moribund ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-sniper-battery (process-focusable)
|
|
((incoming-attack-id uint32 :offset-assert 208)
|
|
(actor-group uint32 :offset-assert 212)
|
|
(actor-group-count int32 :offset-assert 216)
|
|
(known-vulnerable-this-frame basic :offset-assert 220)
|
|
(during-movement-sound uint32 :offset-assert 224)
|
|
(run-once basic :offset-assert 228)
|
|
(halted basic :offset-assert 232)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xec
|
|
:flag-assert #x21007000ec
|
|
(:methods
|
|
(cty-sniper-battery-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
vulnerable ;; 29
|
|
die ;; 30
|
|
explode ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern cty-sniper-button-top-handler function)
|
|
;; (define-extern cty-sniper-button-top-genpost function)
|
|
;; (define-extern cty-sniper-button-top-init-by-other function)
|
|
;; (define-extern *cty-sniper-battery-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern cty-sniper-battery-handler function)
|
|
;; (define-extern cty-sniper-battery-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-sniper-turret ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-city-sniper-fight (task-manager)
|
|
((sniper-turrets-marker-entity basic :offset-assert 236)
|
|
(check-timer uint64 :offset-assert 244)
|
|
(actor-group uint32 :offset-assert 252)
|
|
(actor-group-count int32 :offset-assert 256)
|
|
(cur-group int8 :offset-assert 260)
|
|
(win-time uint64 :offset-assert 268)
|
|
(music-started basic :offset-assert 276)
|
|
(torn-said-turret-rising basic :offset-assert 280)
|
|
(torn-said-dodge basic :offset-assert 284)
|
|
(torn-said-battery-retract basic :offset-assert 288)
|
|
(torn-speech-one-down basic :offset-assert 292)
|
|
(dax-said-bop-the-core basic :offset-assert 296)
|
|
(last-torn-speech-time uint64 :offset-assert 300)
|
|
(battery-retractions-since-last-kaboom int32 :offset-assert 308)
|
|
(minimap connection-minimap :offset-assert 312)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x140
|
|
:flag-assert #x2100c00140
|
|
(:methods
|
|
(task-manager-city-sniper-fight-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
wait ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-cty-sniper-fight (hud)
|
|
((buttons uint32 :offset-assert 2756)
|
|
(num-buttons int8 :offset-assert 2760)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #xac9
|
|
:flag-assert #x1c0a500ac9
|
|
(:methods
|
|
(hud-cty-sniper-fight-method-27 () none) ;; 27
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-sniper-turret-shot (projectile)
|
|
((hit-actor? basic :offset-assert 512)
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-sniper-turret (process-focusable)
|
|
((los los-control :inline :offset-assert 208)
|
|
(reticle uint64 :offset-assert 376)
|
|
(tank-quat quaternion :inline :offset-assert 384)
|
|
(rotate-quat quaternion :inline :offset-assert 400)
|
|
(rotate-rate float :offset-assert 416)
|
|
(rotate-mult float :offset-assert 420)
|
|
(shot-range float :offset-assert 424)
|
|
(fov-mult float :offset-assert 428)
|
|
(offset vector :inline :offset-assert 432)
|
|
(sight-pos vector :inline :offset-assert 448)
|
|
(firing-sight-pos vector :inline :offset-assert 464)
|
|
(gun-timer uint64 :offset-assert 480)
|
|
(gun-elev-jmod joint-mod-rotate-world :inline :offset-assert 496)
|
|
(gun-elev-joint-index int32 :offset-assert 528)
|
|
(gun-elev-desired-rotation quaternion :inline :offset-assert 544)
|
|
(gun-azimuth-jmod joint-mod-rotate-world :inline :offset-assert 560)
|
|
(gun-azimuth-joint-index int32 :offset-assert 592)
|
|
(gun-azimuth-desired-rotation quaternion :inline :offset-assert 608)
|
|
(gun-elev float :offset-assert 624)
|
|
(gun-elev-cam float :offset-assert 628)
|
|
(gun-aims-from-joint int32 :offset-assert 632)
|
|
(gun-spread float :offset-assert 636)
|
|
(gun-current-aim-location vector :inline :offset-assert 640)
|
|
(gun-elbow-jmod joint-mod-rotate-local :inline :offset-assert 656)
|
|
(gun-shoulder-jmod joint-mod-rotate-local :inline :offset-assert 688)
|
|
(pos-cam-offset vector :inline :offset-assert 720)
|
|
(flags uint16 :offset-assert 736)
|
|
(turn-sound-id uint32 :offset-assert 740)
|
|
(h-reticle-strip uint64 :offset-assert 744)
|
|
(minimap connection-minimap :offset-assert 752)
|
|
(actor-group uint32 :offset-assert 756)
|
|
(actor-group-count int32 :offset-assert 760)
|
|
(hud-buttons uint64 :offset-assert 768)
|
|
)
|
|
:method-count-assert 42
|
|
:size-assert #x308
|
|
:flag-assert #x2a02900308
|
|
(:methods
|
|
(cty-sniper-turret-method-35 () none) ;; 35
|
|
(cty-sniper-turret-method-36 () none) ;; 36
|
|
(cty-sniper-turret-method-37 () none) ;; 37
|
|
(cty-sniper-turret-method-38 () none) ;; 38
|
|
(cty-sniper-turret-method-39 () none) ;; 39
|
|
(cty-sniper-turret-method-40 () none) ;; 40
|
|
(cty-sniper-turret-method-41 () none) ;; 41
|
|
)
|
|
(:state-methods
|
|
waiting-for-batteries ;; 28
|
|
asleep ;; 29
|
|
locked-on ;; 32
|
|
ready ;; 30
|
|
fire ;; 31
|
|
die ;; 33
|
|
explode ;; 34
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype simple-prim-turret-reticle (simple-prim)
|
|
((h-parent-turret uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #xd8
|
|
:flag-assert #x1a006000d8
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cty-sniper-turret-reticle (process)
|
|
((ring-inner basic :offset-assert 128)
|
|
(ring-middle basic :offset-assert 132)
|
|
(ring-outer basic :offset-assert 136)
|
|
(ring-inner-radius float :offset-assert 140)
|
|
(ring-middle-radius float :offset-assert 144)
|
|
(ring-outer-radius float :offset-assert 148)
|
|
(h-parent-turret uint64 :offset-assert 152)
|
|
(root basic :offset-assert 160)
|
|
(wander-offset UNKNOWN 2 :offset-assert 176)
|
|
(wander-offset-reset-time uint64 :offset-assert 208)
|
|
(inner-ring-offset float :offset-assert 216)
|
|
(middle-ring-offset float :offset-assert 220)
|
|
(outer-ring-offset float :offset-assert 224)
|
|
(ring-scale-multiplier float :offset-assert 228)
|
|
(reticle-looping-sound uint32 :offset-assert 232)
|
|
(reticle-lockon-sound uint32 :offset-assert 236)
|
|
(current-color uint32 :offset-assert 240)
|
|
(current-alpha uint8 :offset-assert 244)
|
|
(lockon-start-time uint64 :offset-assert 248)
|
|
(flags uint8 :offset-assert 256)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #x101
|
|
:flag-assert #x1500900101
|
|
(:methods
|
|
(cty-sniper-turret-reticle-method-16 () none) ;; 16
|
|
(cty-sniper-turret-reticle-method-17 () none) ;; 17
|
|
(cty-sniper-turret-reticle-method-18 () none) ;; 18
|
|
(cty-sniper-turret-reticle-method-19 () none) ;; 19
|
|
(cty-sniper-turret-reticle-method-20 () none) ;; 20
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
lock ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *cty-sniper-fight-kg-squad-member-settings* object)
|
|
;; (define-extern *range-ftexplo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-ftexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-sniper-turret-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-ftexplo-color* curve-color-fast)
|
|
;; (define-extern *range-ftexplo-alpha* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ftexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ftexplo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-sniper-turret-explosion-texture-curve-settings* object)
|
|
;; (define-extern cty-sniper-turret-shot-move function)
|
|
;; (define-extern spawn-cty-sniper-turret-projectile function)
|
|
;; (define-extern cty-sniper-turret-reticle-init-by-other function)
|
|
;; (define-extern sloppy-lead-player-location function)
|
|
;; (define-extern cty-sniper-turret-reticle-post function)
|
|
;; (define-extern cty-sniper-turret-reticle-handler function)
|
|
;; (define-extern *cty-sniper-turret-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern citysniper-draw-2d-hud function)
|
|
;; (define-extern sniper-turret-post function)
|
|
;; (define-extern cty-sniper-turret-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; eco-green-collider ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype eco-green-collider (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:methods
|
|
(eco-green-collider-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern eco-green-collider-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; forest-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype forest-states (structure)
|
|
((light light-state :inline :offset-assert 0)
|
|
(gun-values UNKNOWN 3 :offset-assert 8)
|
|
(fog-interp float :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-forest-lights function)
|
|
;; (define-extern update-mood-forest function) ;; (function mood-context float int none :behavior time-of-day-proc)
|
|
;; (define-extern set-forest-gun-flash! function)
|
|
;; (define-extern set-forest-fog-interp! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mined-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *mined-tfrag-texture-anim-array* texture-anim-array)
|
|
;; (define-extern set-mined-pillar-texture! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; forest-kill-plants ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-forest-plants (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-green-eco-gauge (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype eco-green-trail-tracker (light-trail-tracker)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xac
|
|
:flag-assert #x15003000ac
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-forest-plants (task-manager)
|
|
((plant-manager-entity basic :offset-assert 236)
|
|
(actor-group uint32 :offset-assert 240)
|
|
(actor-group-count int32 :offset-assert 244)
|
|
(plants basic :offset-assert 248)
|
|
(check-timer uint64 :offset-assert 252)
|
|
(displayed-hint? basic :offset-assert 260)
|
|
(trail-handle uint64 :offset-assert 268)
|
|
(hud-green-eco uint64 :offset-assert 212)
|
|
(updated-minimap? basic :offset-assert 276)
|
|
(cam-setting-timer uint64 :offset-assert 284)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x128
|
|
:flag-assert #x2100b00128
|
|
(:methods
|
|
(task-manager-forest-plants-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *eco-width-curve* curve2d-fast)
|
|
;; (define-extern *eco-alpha-curve* curve2d-fast)
|
|
;; (define-extern *eco-color-curve-green* curve-color-fast)
|
|
;; (define-extern *eco-green-trail* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; forest-ring-chase ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype for-race-ring-finder (process-drawable)
|
|
((path-pos float :offset-assert 200)
|
|
(sound-id uint32 :offset-assert 204)
|
|
(ring-finder-speed float :offset-assert 208)
|
|
(part-subsampler basic :offset-assert 212)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd8
|
|
:flag-assert #x17006000d8
|
|
(:methods
|
|
(for-race-ring-finder-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
find ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-race-ring (process-drawable)
|
|
((mat matrix :inline :offset-assert 208)
|
|
(taskman uint64 :offset-assert 272)
|
|
(is-final? basic :offset-assert 280)
|
|
(part-final basic :offset-assert 284)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x120
|
|
:flag-assert #x1800a00120
|
|
(:methods
|
|
(for-race-ring-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
dormant ;; 20
|
|
idle ;; 21
|
|
die ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype for-statue (process-drawable)
|
|
((id int32 :offset-assert 200)
|
|
(sound-id uint32 :offset-assert 204)
|
|
(part-eyes basic :offset-assert 208)
|
|
(alpha float :offset-assert 212)
|
|
)
|
|
:method-count-assert 29
|
|
:size-assert #xd8
|
|
:flag-assert #x1d006000d8
|
|
(:methods
|
|
(for-statue-method-27 () none) ;; 27
|
|
(for-statue-method-28 () none) ;; 28
|
|
)
|
|
(:state-methods
|
|
dormant ;; 20
|
|
idle ;; 21
|
|
rise ;; 22
|
|
active ;; 23
|
|
open-eyes ;; 24
|
|
complete ;; 25
|
|
explode ;; 26
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-forest-ring-chase (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype forest-path-points-static (structure)
|
|
((points uint32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype forest-path-array-static (structure)
|
|
((paths basic :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype forest-ring-path-control (path-control)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #x24
|
|
:flag-assert #x2000000024
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype forest-path-array (structure)
|
|
((paths basic :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-forest-ring-chase (task-manager)
|
|
((ring-manager-entity basic :offset-assert 236)
|
|
(actor-group uint32 :offset-assert 240)
|
|
(actor-group-count int32 :offset-assert 244)
|
|
(current-statue uint8 :offset-assert 248)
|
|
(current-ring uint8 :offset-assert 249)
|
|
(check-timer uint64 :offset-assert 252)
|
|
(use-camera? basic :offset-assert 260)
|
|
(path-ctrl UNKNOWN 5 :offset-assert 264)
|
|
(ring-finder uint64 :offset-assert 348)
|
|
(found-ring? basic :offset-assert 356)
|
|
(cam-timer uint64 :offset-assert 364)
|
|
(cam-timer-set? basic :offset-assert 372)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x17c
|
|
:flag-assert #x210100017c
|
|
(:methods
|
|
(task-manager-forest-ring-chase-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-forest-ring-resolution (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern print-ring-positions function)
|
|
;; (define-extern for-race-ring-finder-init-by-other function)
|
|
;; (define-extern for-race-ring-cleared? function)
|
|
;; (define-extern *for-statue-played-hint?* object)
|
|
;; (define-extern *for-statue-debris-params* debris-static-params)
|
|
;; (define-extern *for-ring-times* array)
|
|
;; (define-extern *forest-path-array-lengths* array)
|
|
;; (define-extern *forest-path-point-lengths* array)
|
|
;; (define-extern *forest-ring-paths* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; forest-tasks ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype task-manager-forest-machine (task-manager)
|
|
((manager-entity basic :offset-assert 236)
|
|
(actor-group uint32 :offset-assert 240)
|
|
(actor-group-count int32 :offset-assert 244)
|
|
(max-neo-spawned-enemies int32 :offset-assert 248)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x100
|
|
:flag-assert #x2200800100
|
|
(:methods
|
|
(task-manager-forest-machine-method-32 () none) ;; 32
|
|
(task-manager-forest-machine-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-forest-machine-resolution (task-manager)
|
|
((manager-entity basic :offset-assert 236)
|
|
(actor-group uint32 :offset-assert 240)
|
|
(actor-group-count int32 :offset-assert 244)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xfc
|
|
:flag-assert #x20008000fc
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype railx-states-fora (structure)
|
|
((pulses UNKNOWN 4 :offset-assert 0)
|
|
(blue pulse-state :inline :offset-assert 0)
|
|
(yellow pulse-state :inline :offset-assert 16)
|
|
(warp pulse-state :inline :offset-assert 32)
|
|
(spill pulse-state :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
;; (define-extern set-railx-light-brightness-fora! function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; hiphog-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hip-door-b (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hip-mirror (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern hiphog-activate function) ;; (function vector)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; target-flut ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype flut-bank (basic)
|
|
((jump-height-min meters :offset-assert 4)
|
|
(jump-height-max meters :offset-assert 8)
|
|
(double-jump-height-min meters :offset-assert 12)
|
|
(double-jump-height-max meters :offset-assert 16)
|
|
(air-attack-speed meters :offset-assert 20)
|
|
(ground-timeout uint64 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *FLUT-bank* flut-bank)
|
|
;; (define-extern *flut-walk-mods* surface)
|
|
;; (define-extern *flut-run-racer-mods* surface)
|
|
;; (define-extern *flut-run-wild-mods* surface)
|
|
;; (define-extern *flut-jump-wild-mods* surface)
|
|
;; (define-extern *flut-jump-mods* surface)
|
|
;; (define-extern *flut-jump-racer-mods* surface)
|
|
;; (define-extern *flut-double-jump-mods* surface)
|
|
;; (define-extern *flut-double-jump-racer-mods* surface)
|
|
;; (define-extern *flut-run-attack-mods* surface)
|
|
;; (define-extern *flut-air-attack-mods* surface)
|
|
;; (define-extern flut-leg-ik-callback function)
|
|
;; (define-extern flut-update-ik function)
|
|
;; (define-extern target-flut-get-off? function)
|
|
;; (define-extern target-flut-post-post function)
|
|
;; (define-extern target-flut-wild-post function)
|
|
;; (define-extern target-flut-post function)
|
|
;; (define-extern target-flut-falling-anim-trans function)
|
|
;; (define-extern target-flut-hit-ground-anim function)
|
|
;; (define-extern target-flut-standard-event-handler function)
|
|
;; (define-extern target-flut-dangerous-event-handler function)
|
|
;; (define-extern target-fldax-enter function)
|
|
;; (define-extern target-fldax-exit function)
|
|
;; (define-extern target-flut-run-wild object)
|
|
;; (define-extern *flut-get-off-mods* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; tizard ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype tizard (process-focusable)
|
|
((rotation-matrix matrix :inline :offset-assert 208)
|
|
(ground-normal UNKNOWN 2 :offset-assert 272)
|
|
(path-dir vector :inline :offset-assert 304)
|
|
(path-base-u float :offset-assert 320)
|
|
(path-u float :offset-assert 324)
|
|
(path-du float :offset-assert 328)
|
|
(first-run? basic :offset-assert 332)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x150
|
|
:flag-assert #x2400d00150
|
|
(:methods
|
|
(tizard-method-33 () none) ;; 33
|
|
(tizard-method-34 () none) ;; 34
|
|
(tizard-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
walk ;; 29
|
|
turn ;; 30
|
|
turning ;; 31
|
|
die ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern tizard-event-handler function)
|
|
;; (define-extern tizard-tilt-jmod-func function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; dogat ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dogat (nav-enemy)
|
|
((rotation-matrix matrix :inline :offset-assert 624)
|
|
(scared-timer uint64 :offset-assert 688)
|
|
)
|
|
:method-count-assert 192
|
|
:size-assert #x2b8
|
|
:flag-assert #xc0024002b8
|
|
(:methods
|
|
(dogat-method-191 () none) ;; 191
|
|
)
|
|
(:state-methods
|
|
idle ;; 33
|
|
sit-idle ;; 190
|
|
active ;; 34
|
|
notice ;; 35
|
|
flee ;; 36
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *dogat-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern dogat-travel-post function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-squad-member-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mh-squad-member (citizen-enemy)
|
|
((last-choose-new-enemy-time uint64 :offset-assert 1048)
|
|
(current-enemy uint64 :offset-assert 1056)
|
|
(choose-new-enemy-delay-time uint64 :offset-assert 1064)
|
|
(next-update-target-time uint64 :offset-assert 1072)
|
|
)
|
|
:method-count-assert 222
|
|
:size-assert #x438
|
|
:flag-assert #xde03c00438
|
|
(:methods
|
|
(mh-squad-member-method-218 () none) ;; 218
|
|
(mh-squad-member-method-219 () none) ;; 219
|
|
(mh-squad-member-method-220 () none) ;; 220
|
|
(mh-squad-member-method-221 () none) ;; 221
|
|
)
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blow-tower-shared ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype blow-tower-node-info (structure)
|
|
((speed-scalar float :offset-assert 0)
|
|
(accum-dist float :offset-assert 4)
|
|
(accum-time float :offset-assert 8)
|
|
(accum-time-percentage float :offset-assert 12)
|
|
(event-id int32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blow-tower-path (structure)
|
|
((total-time uint64 :offset-assert 0)
|
|
(index int16 :offset-assert 8)
|
|
(pts uint32 :offset-assert 12)
|
|
(node-info uint32 :offset-assert 16)
|
|
(num-nodes int16 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x16
|
|
:flag-assert #x900000016
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype surround-spot (structure)
|
|
((y-rot float :offset-assert 0)
|
|
(x-rot float :offset-assert 4)
|
|
(offset-dir vector :inline :offset-assert 16)
|
|
(turret-pos vector :inline :offset-assert 32)
|
|
(rider-index int16 :offset-assert 48)
|
|
(owner uint64 :offset-assert 56)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blow-tower-path-cursor (structure)
|
|
((curve cubic-curve :inline :offset-assert 0)
|
|
(pos vector :inline :offset-assert 64)
|
|
(norm vector :inline :offset-assert 80)
|
|
(current-time uint64 :offset-assert 96)
|
|
(speed float :offset-assert 104)
|
|
(path blow-tower-path :offset-assert 108)
|
|
(current-tt float :offset-assert 112)
|
|
(interp-tt float :offset-assert 116)
|
|
(current-node-index int16 :offset-assert 120)
|
|
(event-id uint32 :offset-assert 124)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x80
|
|
:flag-assert #xd00000080
|
|
(:methods
|
|
(blow-tower-path-cursor-method-9 () none) ;; 9
|
|
(blow-tower-path-cursor-method-10 () none) ;; 10
|
|
(blow-tower-path-cursor-method-11 () none) ;; 11
|
|
(blow-tower-path-cursor-method-12 () none) ;; 12
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype xform (structure)
|
|
((root transformq :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x30
|
|
:flag-assert #xa00000030
|
|
(:methods
|
|
(xform-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blow-tower-clock (structure)
|
|
((elapsed-clock-time uint64 :offset-assert 0)
|
|
(debug? basic :offset-assert 8)
|
|
(debug-lock-view? basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blow-tower-global-target-info (structure)
|
|
((target-handles UNKNOWN 2 :offset-assert 0)
|
|
(hellcat uint64 :offset-assert 0)
|
|
(pickup uint64 :offset-assert 8)
|
|
(mission-time uint64 :offset-assert 16)
|
|
(debug? basic :offset-assert 24)
|
|
(difficulty-scalar float :offset-assert 28)
|
|
(last-player-attack-time uint64 :offset-assert 32)
|
|
(clock-scalar float :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype blow-tower-speech-instance (speech-instance)
|
|
()
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern find-event-id-index function)
|
|
;; (define-extern find-path-event-id-index function)
|
|
;; (define-extern initialize-hermite-from-path function)
|
|
;; (define-extern process-xform-list function)
|
|
;; (define-extern *blow-tower-targets* object)
|
|
;; (define-extern *blow-tower-speech-list* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blow-tower-data ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *blow-tower-paths* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blow-tower-script ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype blow-tower-cmd (structure)
|
|
((cmd-type uint8 :offset-assert 0)
|
|
(spawn-type uint8 :offset-assert 1)
|
|
(entity-name basic :offset-assert 4)
|
|
(rotate-amount float :offset-assert 8)
|
|
(lock-min float :offset-assert 12)
|
|
(lock-max float :offset-assert 16)
|
|
(target uint8 :offset-assert 20)
|
|
(path-height float :offset-assert 24)
|
|
(event-id uint32 :offset-assert 28)
|
|
(time-offset float :offset-assert 32)
|
|
(clock-scalar float :offset-assert 36)
|
|
(entity-name2 basic :offset-assert 40)
|
|
(snap-view? basic :offset-assert 44)
|
|
(snd-name uint128 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tower-event-group (structure)
|
|
((event-id int32 :offset-assert 0)
|
|
(command-list basic :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
;; (define-extern get-blow-tower-target function)
|
|
;; (define-extern parse-blow-tower-command function)
|
|
;; (define-extern *blow-tower-script* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blow-tower-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *range-bt-roboguard-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-bt-roboguard-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-bt-roboguard-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *bt-grunt-ragdoll-info* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; blow-tower-extra ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype hud-pickup (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-hellcat (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-pickup-arrows (hud)
|
|
((offscreen uint8 :offset-assert 2756)
|
|
(alpha UNKNOWN 2 :offset-assert 2760)
|
|
)
|
|
:method-count-assert 27
|
|
:size-assert #xad0
|
|
:flag-assert #x1b0a500ad0
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-blow-tower ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype bombbot-spawn-record (structure)
|
|
((hand uint64 :offset-assert 0)
|
|
(ent-name basic :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-blow-tower (task-manager)
|
|
((dest-pos vector :inline :offset-assert 240)
|
|
(target-handles UNKNOWN 2 :offset-assert 256)
|
|
(hellcat uint64 :offset-assert 256)
|
|
(pickup uint64 :offset-assert 264)
|
|
(hellcat-turret uint64 :offset-assert 272)
|
|
(mission-elapsed-clock uint64 :offset-assert 280)
|
|
(debug-lock-viewport? basic :offset-assert 288)
|
|
(debug-run-events? basic :offset-assert 292)
|
|
(script basic :offset-assert 296)
|
|
(script-index int16 :offset-assert 300)
|
|
(cmd blow-tower-cmd :inline :offset-assert 304)
|
|
(event-cursor blow-tower-path-cursor :inline :offset-assert 368)
|
|
(last-missile-spawn-time uint64 :offset-assert 496)
|
|
(dest-clock-scalar float :offset-assert 504)
|
|
(clock-scalar float :offset-assert 508)
|
|
(bombbot-path-index int8 :offset-assert 512)
|
|
(hud-arrows uint64 :offset-assert 520)
|
|
(hud-arrow-state uint32 :offset-assert 528)
|
|
(left-arrow-last-time uint64 :offset-assert 536)
|
|
(right-arrow-last-time uint64 :offset-assert 544)
|
|
(show-skill-time uint64 :offset-assert 552)
|
|
(bombbot-records UNKNOWN 3 :offset-assert 560)
|
|
(bombbot-record-index int32 :offset-assert 608)
|
|
(last-missile-ent basic :offset-assert 612)
|
|
(missile-dir-vec vector :inline :offset-assert 624)
|
|
)
|
|
:method-count-assert 40
|
|
:size-assert #x280
|
|
:flag-assert #x2802000280
|
|
(:methods
|
|
(task-manager-blow-tower-method-37 () none) ;; 37
|
|
(task-manager-blow-tower-method-38 () none) ;; 38
|
|
(task-manager-blow-tower-method-39 () none) ;; 39
|
|
)
|
|
(:state-methods
|
|
mission-debug ;; 33
|
|
mission-play ;; 32
|
|
wait-for-exit ;; 34
|
|
active ;; 15
|
|
wind-down-mission ;; 36
|
|
wait-fail ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-gun-manager-target (structure)
|
|
((hand uint64 :offset-assert 0)
|
|
(transformed-pos vector4w :inline :offset-assert 16)
|
|
(size float :offset-assert 32)
|
|
(hit? basic :offset-assert 36)
|
|
(alpha float :offset-assert 40)
|
|
(target-pers-index int32 :offset-assert 44)
|
|
(num-overlap int32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-hud-target-pers (structure)
|
|
((hand uint64 :offset-assert 0)
|
|
(rotate float :offset-assert 8)
|
|
(alpha float :offset-assert 12)
|
|
(size-scalar float :offset-assert 16)
|
|
(outer-alpha float :offset-assert 20)
|
|
(outer-rotate float :offset-assert 24)
|
|
(hold-start-time uint64 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-gun-manager (process)
|
|
((root basic :offset-assert 128)
|
|
(parent-vehicle uint64 :offset-assert 136)
|
|
(params target-turret-params :offset-assert 144)
|
|
(roty deg :offset-assert 148)
|
|
(rotyv deg :offset-assert 152)
|
|
(rotyvv deg :offset-assert 156)
|
|
(roty-min deg :offset-assert 160)
|
|
(roty-max deg :offset-assert 164)
|
|
(rotx deg :offset-assert 168)
|
|
(rotxv deg :offset-assert 172)
|
|
(rotxvv deg :offset-assert 176)
|
|
(rotx-min deg :offset-assert 180)
|
|
(rotx-max deg :offset-assert 184)
|
|
(dest-roty deg :offset-assert 188)
|
|
(dest-rotx deg :offset-assert 192)
|
|
(aim-quat quaternion :inline :offset-assert 208)
|
|
(parent-quat quaternion :inline :offset-assert 224)
|
|
(last-parent-xform matrix :inline :offset-assert 240)
|
|
(hit-pos vector :inline :offset-assert 304)
|
|
(aim-dir vector :inline :offset-assert 320)
|
|
(found-target? basic :offset-assert 336)
|
|
(target-hand uint64 :offset-assert 344)
|
|
(target-start-find-time uint64 :offset-assert 352)
|
|
(hud-aim hud-sprite :inline :offset-assert 368)
|
|
(hud-target hud-sprite :inline :offset-assert 432)
|
|
(hud-target-inner hud-sprite :inline :offset-assert 496)
|
|
(rot-y-shift float :offset-assert 548)
|
|
(dest-rot-y-shift float :offset-assert 552)
|
|
(enable-controls? basic :offset-assert 556)
|
|
(lock-control-time uint64 :offset-assert 560)
|
|
(fire-index uint32 :offset-assert 568)
|
|
(last-fire-time uint64 :offset-assert 576)
|
|
(can-exit? basic :offset-assert 584)
|
|
(is-snapping? basic :offset-assert 588)
|
|
(onscreen-targets UNKNOWN 32 :offset-assert 592)
|
|
(num-onscreen-targets int32 :offset-assert 2640)
|
|
(hud-pers UNKNOWN 32 :offset-assert 2648)
|
|
(rot-y-seek-rate float :offset-assert 4184)
|
|
(cam-quat quaternion :inline :offset-assert 4192)
|
|
(dest-roty-max float :offset-assert 4208)
|
|
(dest-roty-min float :offset-assert 4212)
|
|
(use-roty-min float :offset-assert 4216)
|
|
(use-roty-max float :offset-assert 4220)
|
|
(x-boost-scalar float :offset-assert 4224)
|
|
(y-boost-scalar float :offset-assert 4228)
|
|
(servo-sound uint32 :offset-assert 4232)
|
|
(servo-sound-state uint64 :offset-assert 4240)
|
|
(servo-state-time uint64 :offset-assert 4248)
|
|
(aim-pos vector :inline :offset-assert 4256)
|
|
(aim-dir vector :inline :offset-assert 320)
|
|
(look-cursor blow-tower-path-cursor :inline :offset-assert 4288)
|
|
(look-time-offset uint64 :offset-assert 4416)
|
|
(look-time-scalar float :offset-assert 4424)
|
|
(look-mode uint8 :offset-assert 4428)
|
|
(look-ent basic :offset-assert 4432)
|
|
(look-proc uint64 :offset-assert 4440)
|
|
(last-beep-time uint64 :offset-assert 4448)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #x1168
|
|
:flag-assert #x1910f01168
|
|
(:methods
|
|
(bt-gun-manager-method-17 () none) ;; 17
|
|
(bt-gun-manager-method-18 () none) ;; 18
|
|
(bt-gun-manager-method-19 () none) ;; 19
|
|
(bt-gun-manager-method-20 () none) ;; 20
|
|
(bt-gun-manager-method-21 () none) ;; 21
|
|
(bt-gun-manager-method-22 () none) ;; 22
|
|
(bt-gun-manager-method-23 () none) ;; 23
|
|
(bt-gun-manager-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
idle ;; 14
|
|
active ;; 16
|
|
setup ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-obj-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(path blow-tower-path :offset-assert 32)
|
|
(task-man uint64 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cast-rider-spot (structure)
|
|
((rider uint64 :offset-assert 0)
|
|
(offset-pos vector :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype cast-rider-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-bouncer (structure)
|
|
((mag-scalar float :offset-assert 0)
|
|
(duration uint64 :offset-assert 8)
|
|
(num-bounces float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-vehicle-damage-info (structure)
|
|
((segd uint64 :offset-assert 0)
|
|
(seg0 uint64 :offset-assert 8)
|
|
(seg1 uint64 :offset-assert 16)
|
|
(hp-threshold0 float :offset-assert 24)
|
|
(hp-threshold1 float :offset-assert 28)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-vehicle (process-focusable)
|
|
((path-cursor blow-tower-path-cursor :inline :offset-assert 208)
|
|
(task-man uint64 :offset-assert 336)
|
|
(max-hit-points float :offset-assert 344)
|
|
(hit-points float :offset-assert 348)
|
|
(last-attack-id uint32 :offset-assert 352)
|
|
(path-height-offset float :offset-assert 356)
|
|
(start-path-height-offset float :offset-assert 360)
|
|
(dest-path-height-offset float :offset-assert 364)
|
|
(path-height-start uint64 :offset-assert 368)
|
|
(path-height-end uint64 :offset-assert 376)
|
|
(path-pos vector :inline :offset-assert 384)
|
|
(rider-spots basic :offset-assert 400)
|
|
(hud-health uint64 :offset-assert 408)
|
|
(path-height-vel float :offset-assert 416)
|
|
(inited? basic :offset-assert 420)
|
|
(pre-bounce-pos vector :inline :offset-assert 432)
|
|
(bouncers UNKNOWN 3 :offset-assert 448)
|
|
(bounce-start-time uint64 :offset-assert 544)
|
|
(barrel-roll-amount float :offset-assert 552)
|
|
(barrel-roll-quat quaternion :inline :offset-assert 560)
|
|
(barrel-roll-rate-scalar float :offset-assert 576)
|
|
(last-speed float :offset-assert 580)
|
|
(last-vel vector :inline :offset-assert 592)
|
|
(damage-info basic :offset-assert 608)
|
|
(damage-state UNKNOWN 4 :offset-assert 612)
|
|
(mission-fail? basic :offset-assert 628)
|
|
(whoosh-sound uint32 :offset-assert 632)
|
|
(boost-thruster? basic :offset-assert 636)
|
|
(sound-play-end uint64 :offset-assert 640)
|
|
)
|
|
:method-count-assert 44
|
|
:size-assert #x288
|
|
:flag-assert #x2c02100288
|
|
(:methods
|
|
(bt-vehicle-method-29 () none) ;; 29
|
|
(bt-vehicle-method-30 () none) ;; 30
|
|
(bt-vehicle-method-31 () none) ;; 31
|
|
(bt-vehicle-method-32 () none) ;; 32
|
|
(bt-vehicle-method-33 () none) ;; 33
|
|
(bt-vehicle-method-34 () none) ;; 34
|
|
(bt-vehicle-method-35 () none) ;; 35
|
|
(bt-vehicle-method-36 () none) ;; 36
|
|
(bt-vehicle-method-37 () none) ;; 37
|
|
(bt-vehicle-method-38 () none) ;; 38
|
|
(bt-vehicle-method-39 () none) ;; 39
|
|
(bt-vehicle-method-40 () none) ;; 40
|
|
(bt-vehicle-method-41 () none) ;; 41
|
|
(bt-vehicle-method-42 () none) ;; 42
|
|
(bt-vehicle-method-43 () none) ;; 43
|
|
)
|
|
(:state-methods
|
|
die ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-pickup (bt-vehicle)
|
|
((spots UNKNOWN 4 :offset-assert 656)
|
|
(riders UNKNOWN 2 :offset-assert 912)
|
|
(quat-before-roll quaternion :inline :offset-assert 928)
|
|
(start-hit-time uint64 :offset-assert 944)
|
|
(roboguard-attackers UNKNOWN 2 :offset-assert 952)
|
|
(desired-thruster-length float :offset-assert 968)
|
|
(pickup-barrels UNKNOWN 2 :offset-assert 976)
|
|
)
|
|
:method-count-assert 51
|
|
:size-assert #x3e0
|
|
:flag-assert #x33036003e0
|
|
(:methods
|
|
(bt-pickup-method-46 () none) ;; 46
|
|
(bt-pickup-method-47 () none) ;; 47
|
|
(bt-pickup-method-48 () none) ;; 48
|
|
(bt-pickup-method-49 () none) ;; 49
|
|
(bt-pickup-method-50 () none) ;; 50
|
|
)
|
|
(:state-methods
|
|
wait-for-player ;; 44
|
|
die ;; 28
|
|
path-follow ;; 45
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype bt-hellcat (bt-vehicle)
|
|
((jmod-turret-guns joint-mod-rotate-world :inline :offset-assert 656)
|
|
(child-turret uint64 :offset-assert 688)
|
|
(spots UNKNOWN 12 :offset-assert 704)
|
|
(assigned-spots UNKNOWN 2 :offset-assert 1472)
|
|
(grunt-rider uint64 :offset-assert 1488)
|
|
(grunt-rider-boarded? uint64 :offset-assert 1496)
|
|
(rider-pitch float :offset-assert 1504)
|
|
(pitch-quat quaternion :inline :offset-assert 1520)
|
|
(roll-amount float :offset-assert 1536)
|
|
(dest-roll-amount float :offset-assert 1540)
|
|
(roll-amount-seek-rate float :offset-assert 1544)
|
|
(quat-before-bounce quaternion :inline :offset-assert 1552)
|
|
(quat-grunt-tilt quaternion :inline :offset-assert 1568)
|
|
(jmod-lgun joint-mod-rotate-local :inline :offset-assert 1584)
|
|
(jmod-rgun joint-mod-rotate-local :inline :offset-assert 1616)
|
|
(jmod-barrels UNKNOWN 4 :offset-assert 1648)
|
|
(barrel-fire-state UNKNOWN 4 :offset-assert 1904)
|
|
(engine-sound uint32 :offset-assert 1920)
|
|
(thrust-sound uint32 :offset-assert 1924)
|
|
(land-grunt-offset float :offset-assert 1928)
|
|
)
|
|
:method-count-assert 52
|
|
:size-assert #x78c
|
|
:flag-assert #x340710078c
|
|
(:methods
|
|
(bt-hellcat-method-46 () none) ;; 46
|
|
(bt-hellcat-method-47 () none) ;; 47
|
|
(bt-hellcat-method-48 () none) ;; 48
|
|
(bt-hellcat-method-49 () none) ;; 49
|
|
(bt-hellcat-method-50 () none) ;; 50
|
|
(bt-hellcat-method-51 () none) ;; 51
|
|
)
|
|
(:state-methods
|
|
wait-for-player ;; 44
|
|
player-riding ;; 45
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *blow-tower-bombbat-path-cache* array)
|
|
;; (define-extern bt-vehicle-handler function)
|
|
;; (define-extern *bt-height-adjust* object)
|
|
;; (define-extern *bt-pickup-damage-info* array)
|
|
;; (define-extern *bt-hellcat-gun-nodes* array)
|
|
;; (define-extern *bt-hellcat-damage-info* array)
|
|
;; (define-extern *bt-turret-params* object)
|
|
;; (define-extern bt-gun-manager-init-by-other function)
|
|
;; (define-extern bt-gun-manager-handler function)
|
|
;; (define-extern *fov-to-use* object)
|
|
;; (define-extern cam-bt-gun state)
|
|
;; (define-extern *bt-clamp-curve-x* object)
|
|
;; (define-extern *bt-accel-curve* object)
|
|
;; (define-extern bt-hellcat-init-by-other function)
|
|
;; (define-extern draw-path-blow-curve function)
|
|
;; (define-extern bt-pickup-init-by-other function)
|
|
;; (define-extern bt-force-show-hud function)
|
|
;; (define-extern *blow-tower-kg-squad-member-settings* object)
|
|
;; (define-extern clamp-to-ground function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; lfacrm1-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype lfacrm1-states (structure)
|
|
((door-current-interp float :offset-assert 0)
|
|
(door-target-interp float :offset-assert 4)
|
|
(blink float :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xc
|
|
:flag-assert #x90000000c
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lfac-hanger-door (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-lfacrm1-lights function)
|
|
;; (define-extern update-mood-lfacrm1 function)
|
|
;; (define-extern set-lfacrm1-door! function)
|
|
;; (define-extern lfac-hanger-door-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gun-dummy-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-func-ground-spark-bounce function)
|
|
;; (define-extern spt-func-part-dummy-explode-spider-bomb function)
|
|
;; (define-extern check-gungame-piece-ground function) ;; (function sparticle-system sparticle-cpuinfo matrix none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gungame-data ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gungame-crate (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(pos-x float :offset-assert 0)
|
|
(pos-y float :offset-assert 4)
|
|
(pos-z float :offset-assert 8)
|
|
(angle float :offset-assert 12)
|
|
(ammo int32 :offset-assert 16) ;; pickup-type
|
|
(num uint32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *entrance-gungame-crates-pos* array) ;; (array gungame-crate)
|
|
;; (define-extern *gungame-red-crates-pos* array) ;; (array gungame-crate)
|
|
;; (define-extern *gungame-yellow-crates-pos* array) ;; (array gungame-crate)
|
|
;; (define-extern *gungame-blue-crates-pos* array) ;; (array gungame-crate)
|
|
;; (define-extern *gungame-peace-crates-pos* array) ;; (array gungame-crate)
|
|
;; (define-extern *course1-path-global-info* array)
|
|
;; (define-extern *course2-path-global-info* array)
|
|
;; (define-extern *course3-path-global-info* array)
|
|
;; (define-extern *course4-path-global-info* array)
|
|
;; (define-extern *yellow-training-path-global-info* array) ;; (array tpath-info)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gungame-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gungame-door (process-drawable)
|
|
((front? basic :offset-assert 200)
|
|
(close-sound sound-id :offset-assert 204) ;; guessed by decompiler
|
|
(train uint64 :offset-assert 208) ;; handle
|
|
(other-door uint64 :offset-assert 216)
|
|
(want-close? basic :offset-assert 224)
|
|
)
|
|
:method-count-assert 28
|
|
:size-assert #xe4
|
|
:flag-assert #x1c007000e4
|
|
(:methods
|
|
(gungame-door-method-25 () none) ;; 25
|
|
(gungame-door-method-26 () none) ;; 26
|
|
(gungame-door-method-27 () none) ;; 27
|
|
)
|
|
(:state-methods
|
|
idle ;; 20, old: (idle () _type_ :state 20)
|
|
force-close ;; 23, old: (gungame-door-method-23 (_type_) symbol 23)
|
|
opened ;; 24, old: (gungame-door-method-24 (_type_) symbol 24)
|
|
open ;; 21, old: (open () _type_ :state 21)
|
|
close ;; 22, old: (close () _type_ :state 22)
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern gungame-door-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gungame-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; gungame-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-birth-func-brightness-part-fma-daxter-guncourse-slide-dust function)
|
|
;; (define-extern spt-birth-func-brightness-part-fma-daxter-guncourse-land-dust function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; vinroom-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern birth-func-vinroom-sphere function) ;; (function sparticle-system sparticle-cpuinfo sprite-vec-data-3d sparticle-launcher sparticle-launch-state none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; prebot-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern birth-func-pillar-rocks-bounce function)
|
|
;; (define-extern spt-func-pillar-rocks-bounce1 function)
|
|
;; (define-extern spt-func-pillar-rocks-bounce2 function)
|
|
;; (define-extern spt-func-pillar-rocks-bounce3 function)
|
|
;; (define-extern spt-birth-func-brightness-prebot-eco-pillar-rocks function)
|
|
;; (define-extern spt-birth-func-brightness-prebot-eco-pillar-rocks2 function)
|
|
;; (define-extern spt-birth-func-brightness-prebot-eco-pillar-rocks3 function)
|
|
;; (define-extern spt-birth-func-part-prebot-eco-pillar-rocks function)
|
|
;; (define-extern spt-func-part-prebot-eco-pillar-rocks function)
|
|
;; (define-extern spt-birth-func-part-prebot-eco-pillar-rocks-bounce1 function)
|
|
;; (define-extern spt-func-part-prebot-eco-pillar-rocks-bounce1 function)
|
|
;; (define-extern spt-birth-func-part-prebot-eco-pillar-rocks-bounce2 function)
|
|
;; (define-extern *range-mine-boss-stuck-flame-color* curve-color-fast)
|
|
;; (define-extern *range-mine-boss-stuck-flame-alpha* curve2d-fast)
|
|
;; (define-extern *range-mine-boss-stuck-flame-scale-x* curve2d-fast)
|
|
;; (define-extern *range-mine-boss-stuck-flame-scale-y* curve2d-fast)
|
|
;; (define-extern *r-curve-mine-boss-stuck-flame* curve2d-fast)
|
|
;; (define-extern *g-curve-mine-boss-stuck-flame* curve2d-fast)
|
|
;; (define-extern *b-curve-mine-boss-stuck-flame* curve2d-fast)
|
|
;; (define-extern *curve-mine-boss-stuck-flame-alpha* curve2d-fast)
|
|
;; (define-extern *curve-mine-boss-stuck-flame-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-mine-boss-stuck-flame-scale-y* curve2d-fast)
|
|
;; (define-extern *part-prebot-stuck-flame-curve-settings* object)
|
|
;; (define-extern *range-mine-boss-explo-color* curve-color-fast)
|
|
;; (define-extern *range-mine-boss-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-mine-boss-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-mine-boss-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-mine-boss-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-mine-boss-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-mine-boss-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-prebot-chasm-explosion-texture-curve-settings* object)
|
|
;; (define-extern *range-final-mine-boss-explo-color* curve-color-fast)
|
|
;; (define-extern *range-final-mine-boss-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-final-mine-boss-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-final-mine-boss-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-final-mine-boss-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-final-mine-boss-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-final-mine-boss-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-final-prebot-chasm-explosion-texture-curve-settings* object)
|
|
;; (define-extern spt-birth-func-brightness-prebot-pillar-shatter-rocks function)
|
|
;; (define-extern spt-birth-func-part-prebot-eco-pillar-shatter function)
|
|
;; (define-extern spt-func-part-prebot-eco-pillar-shatter function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ljkdxvin-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *ljkdxvin-texture-anim-array* texture-anim-array)
|
|
;; (define-extern ljkdxvin-texture-anim-func function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; precurc-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; external-player-control ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype player-controller-init-params (structure)
|
|
((mode basic :offset-assert 0)
|
|
(flags uint32 :offset-assert 4)
|
|
(targ-pos vector :inline :offset-assert 16)
|
|
(notify-proc uint64 :offset-assert 32)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype player-controller (process-focusable)
|
|
((params player-controller-init-params :inline :offset-assert 208)
|
|
(targ-pos vector :inline :offset-assert 256)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x110
|
|
:flag-assert #x2400900110
|
|
(:methods
|
|
(player-controller-method-32 () none) ;; 32
|
|
(player-controller-method-33 () none) ;; 33
|
|
(player-controller-method-34 () none) ;; 34
|
|
(player-controller-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
idle ;; 28
|
|
clip-to-nav-mesh ;; 30
|
|
lock ;; 31
|
|
active ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *target-controller-pad* cpad-info)
|
|
;; (define-extern setup-control-pad function)
|
|
;; (define-extern set-pad-world-dir function)
|
|
;; (define-extern override-player-controls function)
|
|
;; (define-extern player-controller-init-by-other function)
|
|
;; (define-extern player-controller-event-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wcar-marauder-b ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype v-marauder-b (wcar-base)
|
|
((jmod-axles UNKNOWN 4 :offset-assert 2752)
|
|
(jmod-gun-x joint-mod-rotate-local :inline :offset-assert 2880)
|
|
(jmod-gun-y joint-mod-rotate-local :inline :offset-assert 2912)
|
|
(turret-control turret-control :inline :offset-assert 2944)
|
|
)
|
|
:method-count-assert 203
|
|
:size-assert #xbe0
|
|
:flag-assert #xcb0b600be0
|
|
(:state-methods
|
|
explode ;; 60
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *v-marauder-b-turret-control-info* object)
|
|
;; (define-extern *v-marauder-b-turret-guard-settings* object)
|
|
;; (define-extern *v-marauder-b-constants* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-chase-path-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype deschase-node (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(pos-x float :offset-assert 0)
|
|
(pos-y float :offset-assert 4)
|
|
(pos-z float :offset-assert 8)
|
|
(speed float :offset-assert 16)
|
|
(next-node int32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype deschase-path (structure)
|
|
((node-count uint16 :offset-assert 0)
|
|
(node uint32 :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-chase-path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *desert-chase-marauder-path* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-chase ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype deschase-point (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(i-node int8 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype v-catapult-shot-embers (metalhead-grenade-shot)
|
|
((ptracker-proc uint64 :offset-assert 536)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype catapult-target (process-drawable)
|
|
((alpha float :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:methods
|
|
(catapult-target-method-21 () none) ;; 21
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype deschase-vehicle (structure)
|
|
((handle uint64 :offset-assert 0)
|
|
(wait-timer uint64 :offset-assert 8)
|
|
(shot-fired? basic :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-chase-ambush-manager (task-manager)
|
|
((marauder-nav-mesh basic :offset-assert 240)
|
|
(marauder UNKNOWN 5 :offset-assert 248)
|
|
(m-free-list basic :offset-assert 288)
|
|
(marauder-count uint8 :offset-assert 292)
|
|
(total-spawned uint8 :offset-assert 293)
|
|
(check-timer uint64 :offset-assert 296)
|
|
(marauder-entity basic :offset-assert 304)
|
|
(h-player-controller uint64 :offset-assert 312)
|
|
(player-moved? basic :offset-assert 320)
|
|
(vehicle-nav-mesh basic :offset-assert 324)
|
|
(vehicle UNKNOWN 4 :offset-assert 328)
|
|
(vehicle-count uint8 :offset-assert 456)
|
|
(v-free-list basic :offset-assert 460)
|
|
(total-veh-spawned uint8 :offset-assert 464)
|
|
(target-point UNKNOWN 4 :offset-assert 480)
|
|
(last-shot-time uint64 :offset-assert 544)
|
|
)
|
|
:method-count-assert 36
|
|
:size-assert #x228
|
|
:flag-assert #x2401b00228
|
|
(:methods
|
|
(desert-chase-ambush-manager-method-32 () none) ;; 32
|
|
(desert-chase-ambush-manager-method-33 () none) ;; 33
|
|
(desert-chase-ambush-manager-method-34 () none) ;; 34
|
|
(desert-chase-ambush-manager-method-35 () none) ;; 35
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype deschase-artifact (process-drawable)
|
|
((arrow uint64 :offset-assert 200)
|
|
(pos vector :inline :offset-assert 208)
|
|
(angs vector :inline :offset-assert 224)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xf0
|
|
:flag-assert #x17007000f0
|
|
(:methods
|
|
(deschase-artifact-method-21 () none) ;; 21
|
|
(deschase-artifact-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-desert-chase-marauders (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype deschase-vehicle-control (structure)
|
|
((vehicle uint64 :offset-assert 0)
|
|
(target uint64 :offset-assert 8)
|
|
(path deschase-path :offset-assert 16)
|
|
(speed float :offset-assert 20)
|
|
(i-node int32 :offset-assert 24)
|
|
(max-dist float :offset-assert 28)
|
|
(speed-factor float :offset-assert 32)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x24
|
|
:flag-assert #xd00000024
|
|
(:methods
|
|
(deschase-vehicle-control-method-9 () none) ;; 9
|
|
(deschase-vehicle-control-method-10 () none) ;; 10
|
|
(deschase-vehicle-control-method-11 () none) ;; 11
|
|
(deschase-vehicle-control-method-12 () none) ;; 12
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-chase-chase-manager (task-manager)
|
|
((h-player-controller uint64 :offset-assert 240)
|
|
(check-timer uint64 :offset-assert 248)
|
|
(speech-time uint64 :offset-assert 256)
|
|
(last-speech int8 :offset-assert 264)
|
|
(death-count int16 :offset-assert 266)
|
|
(max-dist float :offset-assert 268)
|
|
(suck-factor float :offset-assert 272)
|
|
(player-moved? basic :offset-assert 276)
|
|
(control-array UNKNOWN 4 :offset-assert 280)
|
|
(minimap connection-minimap :offset-assert 472)
|
|
(artifact uint64 :offset-assert 480)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x1e8
|
|
:flag-assert #x22017001e8
|
|
(:methods
|
|
(desert-chase-chase-manager-method-32 () none) ;; 32
|
|
(desert-chase-chase-manager-method-33 () none) ;; 33
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
complete ;; 16
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *stronghold-inside-point* object)
|
|
;; (define-extern *stronghold-vehicle-stop-point* object)
|
|
;; (define-extern *stronghold-player-goto-point* object)
|
|
;; (define-extern *stronghold-marauder-start* array)
|
|
;; (define-extern *deschase-catapult-spawn-point* array)
|
|
;; (define-extern catapult-target-handler function)
|
|
;; (define-extern catapult-target-init-by-other function)
|
|
;; (define-extern desert-chase-ambush-intro-sequence function)
|
|
;; (define-extern deschase-artifact-init-by-other function)
|
|
;; (define-extern deschase-artifact-spawn function)
|
|
;; (define-extern *stronghold-vehicle-start* array)
|
|
;; (define-extern *desert-chase-vehicle-start* array)
|
|
;; (define-extern desert-chase-chase-intro-sequence function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; trail-graph ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *trail-graph* trail-graph) ;; trail-graph
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; bike ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype h-bike-base (hvehicle)
|
|
()
|
|
:method-count-assert 162
|
|
:size-assert #x3b0
|
|
:flag-assert #xa2033003b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-bike-a (h-bike-base)
|
|
((fin-fl joint-mod-rotate-local :inline :offset-assert 944)
|
|
(fin-fr joint-mod-rotate-local :inline :offset-assert 976)
|
|
(fin-rl joint-mod-rotate-local :inline :offset-assert 1008)
|
|
(fin-rr joint-mod-rotate-local :inline :offset-assert 1040)
|
|
(rudder joint-mod-rotate-local :inline :offset-assert 1072)
|
|
(brake-l joint-mod-rotate-local :inline :offset-assert 1104)
|
|
(brake-r joint-mod-rotate-local :inline :offset-assert 1136)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x490
|
|
:flag-assert #xa204100490
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-bike-b (h-bike-base)
|
|
((fin-rl joint-mod-rotate-local :inline :offset-assert 944)
|
|
(fin-rr joint-mod-rotate-local :inline :offset-assert 976)
|
|
(rudder joint-mod-rotate-local :inline :offset-assert 1008)
|
|
(rudder-f joint-mod-rotate-local :inline :offset-assert 1040)
|
|
(brake-l joint-mod-rotate-local :inline :offset-assert 1072)
|
|
(brake-r joint-mod-rotate-local :inline :offset-assert 1104)
|
|
(flap-l joint-mod-rotate-local :inline :offset-assert 1136)
|
|
(flap-r joint-mod-rotate-local :inline :offset-assert 1168)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x4b0
|
|
:flag-assert #xa2043004b0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-bike-c (h-bike-base)
|
|
((fin-fl joint-mod-rotate-local :inline :offset-assert 944)
|
|
(fin-fr joint-mod-rotate-local :inline :offset-assert 976)
|
|
(fin-rl joint-mod-rotate-local :inline :offset-assert 1008)
|
|
(fin-rr joint-mod-rotate-local :inline :offset-assert 1040)
|
|
(fin2-fl joint-mod-rotate-local :inline :offset-assert 1072)
|
|
(fin2-fr joint-mod-rotate-local :inline :offset-assert 1104)
|
|
(rudder joint-mod-rotate-local :inline :offset-assert 1136)
|
|
(brake-l joint-mod-rotate-local :inline :offset-assert 1168)
|
|
(brake-r joint-mod-rotate-local :inline :offset-assert 1200)
|
|
(spoiler-l joint-mod-rotate-local :inline :offset-assert 1232)
|
|
(spoiler-r joint-mod-rotate-local :inline :offset-assert 1264)
|
|
)
|
|
:method-count-assert 162
|
|
:size-assert #x510
|
|
:flag-assert #xa204900510
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype h-bike-d (h-bike-a)
|
|
()
|
|
:method-count-assert 162
|
|
:size-assert #x490
|
|
:flag-assert #xa204100490
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *h-bike-explosion-info* vehicle-explosion-info)
|
|
;; (define-extern *h-bike-a-constants* object)
|
|
;; (define-extern *h-bike-b-constants* object)
|
|
;; (define-extern *h-bike-c-constants* object)
|
|
;; (define-extern *h-bike-d-constants* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; guard-grenade ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype reload-grenade-spawn-params (structure)
|
|
((owner uint64 :offset-assert 0)
|
|
(joint-index uint16 :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xa
|
|
:flag-assert #x90000000a
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype reload-grenade (process-drawable)
|
|
((owner uint64 :offset-assert 200)
|
|
(joint-index uint16 :offset-assert 208)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xd2
|
|
:flag-assert #x19006000d2
|
|
(:methods
|
|
(reload-grenade-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
dormant ;; 20
|
|
visible ;; 21
|
|
shrinking ;; 22
|
|
die ;; 23
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern reload-grenade-init-by-other function)
|
|
;; (define-extern reload-grenade-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; guard-states ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern debug-active function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; citizen-norm ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype citizen-norm (civilian)
|
|
()
|
|
:method-count-assert 235
|
|
:size-assert #x464
|
|
:flag-assert #xeb03f00464
|
|
(:state-methods
|
|
knocked ;; 31
|
|
get-up-front ;; 220
|
|
get-up-back ;; 221
|
|
wait ;; 190
|
|
knocked-off-vehicle ;; 234
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *citizen-norm-global-info* civilian-global-info) ;; civilian-global-info
|
|
;; (define-extern *citizen-norm-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasstadb-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype arena-state (structure)
|
|
((time uint64 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-timer-training (hud-timer)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype hud-arena-final-stats (hud)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xac4
|
|
:flag-assert #x1b0a500ac4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype arena-token (process-drawable)
|
|
((trans-y float :offset-assert 200)
|
|
(offset float :offset-assert 204)
|
|
(gspot vector :inline :offset-assert 208)
|
|
(shadow-h uint64 :offset-assert 224)
|
|
)
|
|
:method-count-assert 25
|
|
:size-assert #xe8
|
|
:flag-assert #x19007000e8
|
|
(:methods
|
|
(arena-token-method-23 () none) ;; 23
|
|
(arena-token-method-24 () none) ;; 24
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
hide ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-training-dummy (process-drawable)
|
|
()
|
|
:method-count-assert 23
|
|
:size-assert #xc8
|
|
:flag-assert #x17005000c8
|
|
(:methods
|
|
(wstd-training-dummy-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-arena-training (task-manager)
|
|
((judge-h uint64 :offset-assert 236)
|
|
(arrow-h uint64 :offset-assert 244)
|
|
(hud-stat uint64 :offset-assert 252)
|
|
(check-timer uint64 :offset-assert 260)
|
|
(actor-group uint32 :offset-assert 268)
|
|
(actor-group-count int32 :offset-assert 272)
|
|
(checkpoint-timer float :offset-assert 276)
|
|
(checkpoint-tokens uint64 :offset-assert 284)
|
|
(message-id uint32 :offset-assert 292)
|
|
)
|
|
:method-count-assert 38
|
|
:size-assert #x12c
|
|
:flag-assert #x2600b0012c
|
|
(:methods
|
|
(task-manager-arena-training-method-36 () none) ;; 36
|
|
(task-manager-arena-training-method-37 () none) ;; 37
|
|
)
|
|
(:state-methods
|
|
wait-touch ;; 32
|
|
wait-more ;; 33
|
|
idle ;; 34
|
|
done ;; 35
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-trapdoor (process-drawable)
|
|
((notify-actor basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 22
|
|
:size-assert #xcc
|
|
:flag-assert #x16005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
die ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype wstd-flag (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *arena-state* object)
|
|
;; (define-extern *wstd-training-dummy-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *arena-trainer-checkpoint-valid* object)
|
|
;; (define-extern *arena-trainer-checkpoint-time* object)
|
|
;; (define-extern *arena-trainer-checkpoint-tokens* object)
|
|
;; (define-extern *training-fail* object)
|
|
;; (define-extern *wstd-trapdoor-exploder-params* joint-exploder-static-params)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; citizen-fat ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype citizen-fat (civilian)
|
|
()
|
|
:method-count-assert 234
|
|
:size-assert #x464
|
|
:flag-assert #xea03f00464
|
|
(:state-methods
|
|
knocked ;; 31
|
|
get-up-front ;; 220
|
|
get-up-back ;; 221
|
|
wait ;; 190
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *citizen-fat-global-info* civilian-global-info) ;; civilian-global-info
|
|
;; (define-extern *citizen-fat-nav-enemy-info* nav-enemy-info) ;; nav-enemy-info
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-squad-member ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-lizard ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype desert-lizard (nav-enemy)
|
|
((graph lizard-graph :offset-assert 620)
|
|
(minimap connection-minimap :offset-assert 624)
|
|
(catch-timer uint64 :offset-assert 632)
|
|
(closest-dist float :offset-assert 640)
|
|
(color-index int32 :offset-assert 644)
|
|
(talker-id uint32 :offset-assert 648)
|
|
)
|
|
:method-count-assert 193
|
|
:size-assert #x28c
|
|
:flag-assert #xc10210028c
|
|
(:methods
|
|
(desert-lizard-method-192 () none) ;; 192
|
|
)
|
|
(:state-methods
|
|
notice ;; 35
|
|
flee ;; 36
|
|
catching-daxter ;; 190
|
|
disappear ;; 191
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype desert-lizard-spawner (process)
|
|
((state-time uint64 :offset-assert 128)
|
|
(death-time uint64 :offset-assert 136)
|
|
(lizard uint64 :offset-assert 144)
|
|
(suppress-spawn-time uint64 :offset-assert 152)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #xa0
|
|
:flag-assert #xf002000a0
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *desert-lizard-almost-there-timer* object)
|
|
;; (define-extern *desert-lizard-fact-info* fact-info-enemy-defaults)
|
|
;; (define-extern *desert-lizard-enemy-info* nav-enemy-info)
|
|
;; (define-extern desert-lizard-flee-post function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; cty-borrow-manager ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern cty-borrow-manager-borrow-update function)
|
|
;; (define-extern *cty-borrow-manager-list* object)
|
|
;; (define-extern get-borrow-slot function)
|
|
;; (define-extern parent-also-loaded? function)
|
|
;; (define-extern *faction-sound-list* object)
|
|
;; (define-extern level->sound-bank-name function)
|
|
;; (define-extern insert-into-sound-list function)
|
|
;; (define-extern update-sound-info function)
|
|
;; (define-extern mark-permanent-holds function)
|
|
;; (define-extern city-sound-exists? function)
|
|
;; (define-extern sound-bank-mode->use-count function)
|
|
;; (define-extern add-city-sound-bank-if-possible function)
|
|
;; (define-extern city-sound-expand-want-list function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ctywide-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dummy-alloc (structure)
|
|
((val uint32 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4
|
|
:flag-assert #x900000004
|
|
)
|
|
|#
|
|
|
|
;; (define-extern update-level-info function)
|
|
;; (define-extern ctywide-login function) ;; (function none)
|
|
;; (define-extern ctywide-activate function) ;; (function level symbol none)
|
|
;; (define-extern ctywide-deactivate function) ;; (function none)
|
|
;; (define-extern ctywide-logout function)
|
|
;; (define-extern *traffic-alert-level-force* object) ;; symbol
|
|
;; (define-extern lwide-activate function) ;; (function level symbol none)
|
|
;; (define-extern lwide-deactivate function) ;; (function none)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mhcity-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype mhcity-dark-eco-door (process-focusable)
|
|
((should-break? basic :offset-assert 208)
|
|
(broken-door uint64 :offset-assert 216)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #xe0
|
|
:flag-assert #x21006000e0
|
|
(:state-methods
|
|
broken-idle ;; 32
|
|
idle ;; 28
|
|
cracked ;; 29
|
|
cracked-idle ;; 30
|
|
broken ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-dark-eco-door-broken (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
crack ;; 20
|
|
shatter ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-lump (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-dark-eco-nodule (process-drawable)
|
|
()
|
|
:method-count-assert 22
|
|
:size-assert #xc8
|
|
:flag-assert #x16005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
explode ;; 21
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-ambient-killable (process-focusable)
|
|
((hit-points float :offset-assert 208)
|
|
(drop-type int32 :offset-assert 212)
|
|
(drop-amount float :offset-assert 216)
|
|
(sphere-size float :offset-assert 220)
|
|
(last-attack-id uint32 :offset-assert 224)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #xe4
|
|
:flag-assert #x1f007000e4
|
|
(:methods
|
|
(mhcity-ambient-killable-method-29 () none) ;; 29
|
|
(mhcity-ambient-killable-method-30 () none) ;; 30
|
|
)
|
|
(:state-methods
|
|
die-hidden ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-vein-writhing-large (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-vein-writhing-small (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-claw-finger-small (mhcity-ambient-killable)
|
|
((twitch-speed float :offset-assert 228)
|
|
(twitch-angle-current float :offset-assert 232)
|
|
(twitch-angle-dest float :offset-assert 236)
|
|
(base-quat quaternion :inline :offset-assert 240)
|
|
(jitter-count int8 :offset-assert 256)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x101
|
|
:flag-assert #x2000900101
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-twitch-blade (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-vine-wriggler (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-vine-wriggler-big (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-de-tower-undervines (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-grunt-egg-c (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-grunt-egg-b (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-grunt-egg-d (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-grunt-egg-a (mhcity-ambient-killable)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xe4
|
|
:flag-assert #x20007000e4
|
|
(:state-methods
|
|
idle ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype curve-bubbles-Shape (process-hidden)
|
|
()
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mhcity-tower-door (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern mhcity-dark-eco-door-broken-init-by-other function)
|
|
;; (define-extern *darkeco-nodule-task-nodes* array)
|
|
;; (define-extern mhcity-ambient-killable-event-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; assault-cams ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *assault-cams* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; assault-script ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype assault-spawn-cmd (structure)
|
|
((spawn-delay uint64 :offset-assert 0)
|
|
(command uint8 :offset-assert 8)
|
|
(spawn-type uint16 :offset-assert 10)
|
|
(count int8 :offset-assert 12)
|
|
(spawner-index int8 :offset-assert 13)
|
|
(wait-type uint8 :offset-assert 10)
|
|
(faction-type uint8 :offset-assert 13)
|
|
(wait-time uint64 :offset-assert 0)
|
|
(msg basic :offset-assert 16)
|
|
(path-id int32 :offset-assert 20)
|
|
(event0 int32 :offset-assert 24)
|
|
(event1 int32 :offset-assert 28)
|
|
(event2 int32 :offset-assert 32)
|
|
(speech-type uint64 :offset-assert 40)
|
|
(gun-pickup-type int32 :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype room-powerup-percentage (structure)
|
|
((avg-spawn-rate uint64 :offset-assert 0)
|
|
(percentages UNKNOWN 51 :offset-assert 8)
|
|
(red2 float :offset-assert 116)
|
|
(red3 float :offset-assert 120)
|
|
(yellow2 float :offset-assert 128)
|
|
(yellow3 float :offset-assert 132)
|
|
(blue1 float :offset-assert 136)
|
|
(blue2 float :offset-assert 140)
|
|
(blue3 float :offset-assert 144)
|
|
(darkjak float :offset-assert 36)
|
|
(lightjak float :offset-assert 64)
|
|
(health float :offset-assert 88)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #xd4
|
|
:flag-assert #x9000000d4
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype assault-cmd-context (structure)
|
|
((start-time uint64 :offset-assert 0)
|
|
(state-time uint64 :offset-assert 8)
|
|
(current-command assault-spawn-cmd :inline :offset-assert 16)
|
|
(script basic :offset-assert 68)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x48
|
|
:flag-assert #x900000048
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *port-assault-speech* array)
|
|
;; (define-extern *assault-object-count* array)
|
|
;; (define-extern *assault-fade-dist* array)
|
|
;; (define-extern *assault-graph-classification* array)
|
|
;; (define-extern *assault-faction-lookup* array)
|
|
;; (define-extern *assault-guard-count* array)
|
|
;; (define-extern *assault-citizen-count* array)
|
|
;; (define-extern symbol->assault-target-type function)
|
|
;; (define-extern symbol->speech-type function)
|
|
;; (define-extern symbol->faction-type function)
|
|
;; (define-extern symbol->gun-pickup-type function)
|
|
;; (define-extern parse-assault-command function)
|
|
;; (define-extern *assault-bombbot-paths* array)
|
|
;; (define-extern *assault-scripts* array)
|
|
;; (define-extern *room-goal* array)
|
|
;; (define-extern *room-powerups* array)
|
|
;; (define-extern *room0-script* object)
|
|
;; (define-extern *room1-script* object)
|
|
;; (define-extern *room2-script* object)
|
|
;; (define-extern *room3-script* object)
|
|
;; (define-extern *room4-script* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-centipede-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern birth-func-ground-dirt-bounce function)
|
|
;; (define-extern spt-func-ground-dirt-bounce1 function)
|
|
;; (define-extern spt-func-ground-dirt-bounce2 function)
|
|
;; (define-extern spt-birth-func-brightness-mh-centipede-rocks function)
|
|
;; (define-extern spt-birth-func-brightness-mh-centipede-dirt function)
|
|
;; (define-extern spt-birth-func-brightness-mh-centipede-dust function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-before-breach-rocks function)
|
|
;; (define-extern spt-func-part-mh-centipede-before-breach-rocks function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-breach-dirt function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-breach-rocks function)
|
|
;; (define-extern spt-func-part-mh-centipede-breach-rocks function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-breach-rocks-bounce1 function)
|
|
;; (define-extern spt-func-part-mh-centipede-breach-rocks-bounce1 function)
|
|
;; (define-extern spt-func-ground-dirt-bounce3 function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-breach-rocks-bounce2 function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-impact-dirt function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-impact-rocks function)
|
|
;; (define-extern spt-func-part-mh-centipede-impact-rocks function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-impact-rocks-bounce1 function)
|
|
;; (define-extern spt-func-part-mh-centipede-impact-rocks-bounce1 function)
|
|
;; (define-extern spt-birth-func-brightness-mh-centipede-blood function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-explosion-lots function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-explosion function)
|
|
;; (define-extern *range-mhcent-splash-color* curve-color-fast)
|
|
;; (define-extern *range-mhcent-splash-alpha* curve2d-fast)
|
|
;; (define-extern *range-mhcent-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *range-mhcent-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-mhcent-splash-alpha* curve2d-fast)
|
|
;; (define-extern *curve-mhcent-splash-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-mhcent-splash-scale-y* curve2d-fast)
|
|
;; (define-extern *part-mh-centipede-splash-curve-settings* object)
|
|
;; (define-extern check-mh-centipede-explosion-level function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-shot-explosion-dirt function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-shot-explosion-dust function)
|
|
;; (define-extern spt-birth-func-part-mh-centipede-shot-explosion-bits function)
|
|
;; (define-extern *range-mh-centipede-shot-explo-color* curve-color-fast)
|
|
;; (define-extern *range-mh-centipede-shot-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-mh-centipede-shot-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-mh-centipede-shot-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-mh-centipede-shot-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-mh-centipede-shot-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-mh-centipede-shot-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-mh-centipede-shot-explosion-texture-curve-settings* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mh-centipede ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype nest-hunt-speech-instance (structure)
|
|
((speech uint16 :offset-assert 0)
|
|
(probability float :offset-assert 4)
|
|
(flags uint64 :offset-assert 8)
|
|
(play-count uint32 :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nest-hunt-speech-info (structure)
|
|
((speeches basic :offset-assert 0)
|
|
(play-time uint64 :offset-assert 8)
|
|
(current-random uint64 :offset-assert 16)
|
|
(minimum-interval uint64 :offset-assert 24)
|
|
(random-interval uint64 :offset-assert 32)
|
|
(last-played int8 :offset-assert 40)
|
|
(flags uint8 :offset-assert 41)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2a
|
|
:flag-assert #x90000002a
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype nest-hunt-speech-group (structure)
|
|
((play-time uint64 :offset-assert 0)
|
|
(game-counter-last float :offset-assert 8)
|
|
(info basic :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype rod-spawner (process-drawable)
|
|
((rod uint64 :offset-assert 200)
|
|
(minimap connection-minimap :offset-assert 208)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xd4
|
|
:flag-assert #x17006000d4
|
|
(:state-methods
|
|
wait-for-children ;; 21
|
|
idle ;; 20
|
|
hidden ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-centipede-shot (projectile)
|
|
((trail-part basic :offset-assert 512)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x204
|
|
:flag-assert #x2901900204
|
|
(:state-methods
|
|
moving ;; 23
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-centipede-crater-pt (structure)
|
|
((collision-pt vector :inline :offset-assert 0)
|
|
(normal vector :inline :offset-assert 16)
|
|
(found? basic :offset-assert 32)
|
|
(angle float :offset-assert 36)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x28
|
|
:flag-assert #x900000028
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-centipede-crater-pt-array (structure)
|
|
((points UNKNOWN 20 :offset-assert 0)
|
|
(origin vector :inline :offset-assert 960)
|
|
(radius float :offset-assert 976)
|
|
(current-point int32 :offset-assert 980)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x3d8
|
|
:flag-assert #xc000003d8
|
|
(:methods
|
|
(mh-centipede-crater-pt-array-method-9 () none) ;; 9
|
|
(mh-centipede-crater-pt-array-method-10 () none) ;; 10
|
|
(mh-centipede-crater-pt-array-method-11 () none) ;; 11
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-centipede-anim (structure)
|
|
((anim int32 :offset-assert 0)
|
|
(speed float :offset-assert 4)
|
|
(radius float :offset-assert 8)
|
|
(vulnerable-start float :offset-assert 12)
|
|
(vulnerable-end float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-centipede (process-focusable)
|
|
((launch-position vector :inline :offset-assert 208)
|
|
(landing-position vector :inline :offset-assert 224)
|
|
(flags uint32 :offset-assert 240)
|
|
(incoming-attack-id uint32 :offset-assert 244)
|
|
(hit-points float :offset-assert 248)
|
|
(appearance-order int8 :offset-assert 252)
|
|
(before-breach-part basic :offset-assert 256)
|
|
(breach-part basic :offset-assert 260)
|
|
(dirt-fall-part basic :offset-assert 264)
|
|
(impact-part basic :offset-assert 268)
|
|
(impact-dust-part basic :offset-assert 272)
|
|
(out-of-ground-crater mh-centipede-crater-pt-array :inline :offset-assert 288)
|
|
(into-ground-crater mh-centipede-crater-pt-array :inline :offset-assert 1280)
|
|
(wait-time uint64 :offset-assert 2264)
|
|
(pre-breach-time uint64 :offset-assert 2272)
|
|
(breach-anims basic :offset-assert 2280)
|
|
(shoot-anims basic :offset-assert 2284)
|
|
(current-anim mh-centipede-anim :offset-assert 2288)
|
|
(nose-smack-time uint64 :offset-assert 2296)
|
|
(tail-smack-time uint64 :offset-assert 2304)
|
|
(timeout uint64 :offset-assert 2312)
|
|
(prev-anim-frame float :offset-assert 2320)
|
|
(current-target-position vector :inline :offset-assert 2336)
|
|
(prev-target-position vector :inline :offset-assert 2352)
|
|
(prev-time uint64 :offset-assert 2368)
|
|
(rumble-sound uint32 :offset-assert 2376)
|
|
(rumble-sound-playing basic :offset-assert 2380)
|
|
(ground-sound uint32 :offset-assert 2384)
|
|
(ground-sound-playing basic :offset-assert 2388)
|
|
(legs-sound uint32 :offset-assert 2392)
|
|
(legs-sound-playing basic :offset-assert 2396)
|
|
(minimap connection-minimap :offset-assert 2400)
|
|
(mm-handle uint64 :offset-assert 2408)
|
|
(effect-sphere sphere :offset-assert 2416)
|
|
)
|
|
:method-count-assert 43
|
|
:size-assert #x974
|
|
:flag-assert #x2b09000974
|
|
(:methods
|
|
(mh-centipede-method-36 () none) ;; 36
|
|
(mh-centipede-method-37 () none) ;; 37
|
|
(mh-centipede-method-38 () none) ;; 38
|
|
(mh-centipede-method-39 () none) ;; 39
|
|
(mh-centipede-method-40 () none) ;; 40
|
|
(mh-centipede-method-41 () none) ;; 41
|
|
(mh-centipede-method-42 () none) ;; 42
|
|
)
|
|
(:state-methods
|
|
hidden ;; 28
|
|
wait-on-minimap ;; 29
|
|
wait-off-minimap ;; 30
|
|
pre-breach ;; 31
|
|
breach ;; 32
|
|
shooting ;; 33
|
|
die ;; 34
|
|
test ;; 35
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype mh-centipede-minimap-dot (process-drawable)
|
|
((minimap connection-minimap :offset-assert 200)
|
|
)
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-mh-centipede (task-manager)
|
|
((vehicle-handle uint64 :offset-assert 236)
|
|
(manager-entity basic :offset-assert 244)
|
|
(check-timer uint64 :offset-assert 252)
|
|
(actor-group uint32 :offset-assert 260)
|
|
(actor-group-count int32 :offset-assert 264)
|
|
(last-centipede-position vector :inline :offset-assert 268)
|
|
(last-target-position vector :inline :offset-assert 284)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x130
|
|
:flag-assert #x2100b00130
|
|
(:methods
|
|
(task-manager-mh-centipede-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-nstb-crystal (task-manager)
|
|
((vehicle-handle uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf8
|
|
:flag-assert #x20008000f8
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *mh-centipede-sphere-1* object)
|
|
;; (define-extern *mh-centipede-sphere-2* object)
|
|
;; (define-extern nest-hunt-find-sphere function)
|
|
;; (define-extern nest-hunt-same-sphere function)
|
|
;; (define-extern nest-hunt-volume function)
|
|
;; (define-extern nest-hunt-shake-amp function)
|
|
;; (define-extern *nest-hunt-speech-list* object)
|
|
;; (define-extern *nest-hunt-speech* object)
|
|
;; (define-extern reset-nest-hunt-speeches function)
|
|
;; (define-extern nest-hunt-play-speech function)
|
|
;; (define-extern *mh-centipede-shadow-control* shadow-control)
|
|
;; (define-extern *mh-centipede-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern mh-centipede-minimap-dot-init-by-other function)
|
|
;; (define-extern mh-centipede-active-handler function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; desert-lizard-task ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype lizard-graph-edge (structure)
|
|
((index UNKNOWN 2 :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype lizard-graph (structure)
|
|
((point-count int32 :offset-assert 0)
|
|
(point uint32 :offset-assert 4)
|
|
(edge-count int32 :offset-assert 8)
|
|
(edge uint32 :offset-assert 12)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-catch-lizards (task-manager)
|
|
((corral-pos sphere :inline :offset-assert 236)
|
|
(actor-group uint32 :offset-assert 252)
|
|
(actor-group-count int32 :offset-assert 256)
|
|
(manager-entity basic :offset-assert 260)
|
|
(lizard-count int32 :offset-assert 264)
|
|
(lizards-left int32 :offset-assert 268)
|
|
(sound-id uint32 :offset-assert 272)
|
|
(restart-time uint64 :offset-assert 276)
|
|
(vehicle-handle uint64 :offset-assert 284)
|
|
(vehicle-hit-points float :offset-assert 292)
|
|
(vehicle-turbo-count float :offset-assert 296)
|
|
(lizard-in-corral basic :offset-assert 300)
|
|
(daxter-comment-time uint64 :offset-assert 308)
|
|
(hint-time uint64 :offset-assert 316)
|
|
(arrow-handle uint64 :offset-assert 324)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x150
|
|
:flag-assert #x2300d00150
|
|
(:methods
|
|
(task-manager-desert-catch-lizards-method-33 () none) ;; 33
|
|
(task-manager-desert-catch-lizards-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
active ;; 15
|
|
paused ;; 32
|
|
resolution ;; 17
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype kleever-catch-lizards (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xcc
|
|
:flag-assert #x15005000cc
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype toad-catch-lizards (w-parking-spot)
|
|
()
|
|
:method-count-assert 27
|
|
:size-assert #xf8
|
|
:flag-assert #x1b008000f8
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *desertg-lizard-graph* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; waspal-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *waspal-water-texture-anim-array* texture-anim-array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; throne-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wastrail-graph ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *trail-graph* trail-graph) ;; trail-graph
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasall-part ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern spt-birth-func-brightness-buggy-dirt-bits function)
|
|
;; (define-extern spt-birth-func-part-buggy-dirt-bits function)
|
|
;; (define-extern spt-birth-func-part-buggy-skid-bits function)
|
|
;; (define-extern *wasdoors-range-color-flame* curve-color-fast)
|
|
;; (define-extern *wasdoors-range-alpha-flame* curve2d-fast)
|
|
;; (define-extern *wasdoors-range-scale-flame-x* curve2d-fast)
|
|
;; (define-extern *wasdoors-range-scale-flame-y* curve2d-fast)
|
|
;; (define-extern *r-wasdoors-curve-flame* curve2d-fast)
|
|
;; (define-extern *g-wasdoors-curve-flame* curve2d-fast)
|
|
;; (define-extern *b-wasdoors-curve-flame* curve2d-fast)
|
|
;; (define-extern *wasdoors-curve-alpha-flame* curve2d-fast)
|
|
;; (define-extern *wasdoors-curve-flame-x* curve2d-fast)
|
|
;; (define-extern *wasdoors-curve-flame-y* curve2d-fast)
|
|
;; (define-extern *part-wasdoors-gas-lamp-flame-curve-settings* object)
|
|
;; (define-extern spt-birth-func-brightness-part-desert-boss-slide-dust function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; wasall-tasks ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype dust-storm-randomizer (process)
|
|
((name basic :offset-assert 0)
|
|
(mask process-mask :offset-assert 4)
|
|
(clock basic :offset-assert 8)
|
|
(parent uint32 :offset-assert 12)
|
|
(brother uint32 :offset-assert 16)
|
|
(child uint32 :offset-assert 20)
|
|
(ppointer uint32 :offset-assert 24)
|
|
(self basic :offset-assert 28)
|
|
(pool basic :offset-assert 32)
|
|
(status basic :offset-assert 36)
|
|
(pid int32 :offset-assert 40)
|
|
(main-thread basic :offset-assert 44)
|
|
(top-thread basic :offset-assert 48)
|
|
(entity basic :offset-assert 52)
|
|
(level basic :offset-assert 56)
|
|
(state basic :offset-assert 60)
|
|
(prev-state basic :offset-assert 64)
|
|
(next-state basic :offset-assert 68)
|
|
(state-stack basic :offset-assert 72)
|
|
(trans-hook basic :offset-assert 76)
|
|
(post-hook basic :offset-assert 80)
|
|
(event-hook basic :offset-assert 84)
|
|
(allocated-length int32 :offset-assert 88)
|
|
(heap-base uint32 :offset-assert 92)
|
|
(heap-top uint32 :offset-assert 96)
|
|
(heap-cur uint32 :offset-assert 100)
|
|
(stack-frame-top basic :offset-assert 104)
|
|
(heap kheap :inline :offset-assert 92)
|
|
(connection-list connectable :inline :offset-assert 108)
|
|
(stack UNKNOWN :dynamic :offset-assert 124)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x80
|
|
:flag-assert #xf00000080
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-temple (task-manager)
|
|
((rod-of-god uint64 :offset-assert 240)
|
|
(vehicle uint64 :offset-assert 248)
|
|
(minimap connection-minimap :offset-assert 256)
|
|
(minimap-temple connection-minimap :offset-assert 260)
|
|
)
|
|
:method-count-assert 34
|
|
:size-assert #x108
|
|
:flag-assert #x2200900108
|
|
(:methods
|
|
(task-manager-temple-method-32 () none) ;; 32
|
|
(task-manager-temple-method-33 () none) ;; 33
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-temple-climb (task-manager-temple)
|
|
()
|
|
:method-count-assert 34
|
|
:size-assert #x108
|
|
:flag-assert #x2200900108
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-temple-tests (task-manager-temple)
|
|
()
|
|
:method-count-assert 34
|
|
:size-assert #x108
|
|
:flag-assert #x2200900108
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-interceptors-attack (task-manager)
|
|
((target-set-time uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf8
|
|
:flag-assert #x20008000f8
|
|
(:state-methods
|
|
active ;; 15
|
|
fail ;; 18
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-vehicle-training-1 (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-vehicle-training-2 (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-highlight-vehicle (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype oasis-defense-intro-manager (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-highlight-vehicle-wait (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-vehicle-wait (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-lock-wasdoors (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
(:state-methods
|
|
active ;; 15
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-get-to-corral (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-beast-battle-intro (task-manager)
|
|
((sig-rider-handle uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf8
|
|
:flag-assert #x20008000f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-beast-battle (task-manager)
|
|
((sig-rider-handle uint64 :offset-assert 240)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #xf8
|
|
:flag-assert #x20008000f8
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-desert-beast-battle-end (task-manager)
|
|
()
|
|
:method-count-assert 32
|
|
:size-assert #xf0
|
|
:flag-assert #x20007000f0
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype task-manager-nest-hunt (task-manager)
|
|
((vehicle-handle uint64 :offset-assert 240)
|
|
(sig-handle uint64 :offset-assert 248)
|
|
(minimap-connection connection-minimap :offset-assert 256)
|
|
(showing-desert basic :offset-assert 260)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x108
|
|
:flag-assert #x2000900108
|
|
)
|
|
|#
|
|
|
|
;; (define-extern wasall-kill-duplicate-vehicle function)
|
|
;; (define-extern dust-storm-randomizer-init-by-other function)
|
|
;; (define-extern spawn-dust-storm-randomizer function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ffight-projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype ffight-shot (projectile)
|
|
((hit-actor? basic :offset-assert 512)
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern ffight-shot-move function)
|
|
;; (define-extern spawn-ffight-projectile function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fturret-projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fturret-shot (projectile)
|
|
((hit-actor? basic :offset-assert 512)
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
)
|
|
|#
|
|
|
|
;; (define-extern fturret-shot-move function)
|
|
;; (define-extern spawn-fturret-projectile function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; warf-projectile ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype warf-explosion-sphere (process-drawable)
|
|
((current-alpha float :offset-assert 200)
|
|
(expanding? basic :offset-assert 216)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xdc
|
|
:flag-assert #x17006000dc
|
|
(:methods
|
|
(warf-explosion-sphere-method-21 () none) ;; 21
|
|
(warf-explosion-sphere-method-22 () none) ;; 22
|
|
)
|
|
(:state-methods
|
|
active ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype warf-explosion-sphere-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype warf-projectile (projectile)
|
|
((hit-actor? basic :offset-assert 512)
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
(hit-pos vector :inline :offset-assert 544)
|
|
(last-hit-time uint64 :offset-assert 560)
|
|
(snd-whoosh uint32 :offset-assert 568)
|
|
(muzzle-flash-part basic :offset-assert 576)
|
|
)
|
|
:method-count-assert 46
|
|
:size-assert #x244
|
|
:flag-assert #x2e01d00244
|
|
(:methods
|
|
(warf-projectile-method-41 () none) ;; 41
|
|
(warf-projectile-method-42 () none) ;; 42
|
|
(warf-projectile-method-43 () none) ;; 43
|
|
(warf-projectile-method-44 () none) ;; 44
|
|
(warf-projectile-method-45 () none) ;; 45
|
|
)
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-gun-tower-projectile (projectile)
|
|
((hit-actor? basic :offset-assert 512)
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
)
|
|
:method-count-assert 41
|
|
:size-assert #x220
|
|
:flag-assert #x2901a00220
|
|
(:state-methods
|
|
impact ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gun-warf-shot (projectile)
|
|
((hit-actor? basic :offset-assert 512)
|
|
(tail-pos vector :inline :offset-assert 528)
|
|
(hit-pos vector :inline :offset-assert 544)
|
|
(last-hit-time uint64 :offset-assert 560)
|
|
(snd-whoosh uint32 :offset-assert 568)
|
|
(muzzle-flash-part basic :offset-assert 572)
|
|
(main-shot-part basic :offset-assert 576)
|
|
(shot-aim-part basic :offset-assert 580)
|
|
)
|
|
:method-count-assert 44
|
|
:size-assert #x248
|
|
:flag-assert #x2c01d00248
|
|
(:methods
|
|
(gun-warf-shot-method-41 () none) ;; 41
|
|
(gun-warf-shot-method-42 () none) ;; 42
|
|
(gun-warf-shot-method-43 () none) ;; 43
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern warf-explosion-sphere-init-by-other function)
|
|
;; (define-extern warf-explosion-sphere-event-handler function)
|
|
;; (define-extern spawn-warf-projectile function)
|
|
;; (define-extern spawn-fac-gun-tower-projectile function)
|
|
;; (define-extern warf-projectile-move function)
|
|
;; (define-extern spt-func-factory-move function)
|
|
;; (define-extern spt-func-part-crystal-torpedo-in function)
|
|
;; (define-extern spt-func-part-crystal-torpedo-out function)
|
|
;; (define-extern fac-gun-tower-projectile-move function)
|
|
;; (define-extern gun-warf-shot-move function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fac-robotank-h ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; fac-robotank ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fac-robotank-segment-event (structure)
|
|
((source uint64 :offset-assert 0)
|
|
(event-type basic :offset-assert 8)
|
|
(actor basic :offset-assert 12)
|
|
(pos-norm float :offset-assert 16)
|
|
(param basic :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
;; field param uses ~A with a signed load.
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robotank-segment (structure)
|
|
((flags uint16 :offset-assert 0)
|
|
(max-speed float :offset-assert 4)
|
|
(next-segment int32 :offset-assert 8)
|
|
(next-segment-start float :offset-assert 12)
|
|
(event-count int32 :offset-assert 16)
|
|
(event-tbl uint32 :offset-assert 20)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robotank-path-info (structure)
|
|
((dir vector :inline :offset-assert 0)
|
|
(u float :offset-assert 16)
|
|
(du float :offset-assert 20)
|
|
(du-final float :offset-assert 24)
|
|
(prev-u float :offset-assert 28)
|
|
(max-speed float :offset-assert 32)
|
|
(dist float :offset-assert 36)
|
|
(dir-y-angle float :offset-assert 40)
|
|
(start-y-angle float :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robotank-path-info-array (inline-array-class)
|
|
((data UNKNOWN :dynamic :offset-assert 16)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x10
|
|
:flag-assert #xe00000010
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robotank-wheel-info (structure)
|
|
((jmod basic :offset-assert 0)
|
|
(radius float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robotank-tread-info (structure)
|
|
((wheel UNKNOWN 7 :offset-assert 0)
|
|
(texture texture-anim :offset-assert 112)
|
|
(locator-joint int32 :offset-assert 116)
|
|
(pos vector :inline :offset-assert 128)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x90
|
|
:flag-assert #x900000090
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype fac-robotank (process-focusable)
|
|
((barrel-part basic :offset-assert 208)
|
|
(vibe-jmod joint-mod-blend-local :inline :offset-assert 224)
|
|
(tread UNKNOWN 2 :offset-assert 352)
|
|
(path-info basic :offset-assert 640)
|
|
(flags uint16 :offset-assert 644)
|
|
(mgr uint64 :offset-assert 648)
|
|
(pov-cam-offset UNKNOWN 2 :offset-assert 656)
|
|
(explode-sg basic :offset-assert 688)
|
|
(turret uint64 :offset-assert 696)
|
|
(no-collision-timer uint64 :offset-assert 704)
|
|
(buzz-timer uint64 :offset-assert 712)
|
|
(engine-vibe-rate float :offset-assert 720)
|
|
(engine-vibe-amp float :offset-assert 724)
|
|
(attack-id uint32 :offset-assert 728)
|
|
(path-index int32 :offset-assert 732)
|
|
(path-count int32 :offset-assert 736)
|
|
(continue-index int32 :offset-assert 740)
|
|
(hit-points float :offset-assert 744)
|
|
(engine-sound uint32 :offset-assert 748)
|
|
(engine-sound-playing basic :offset-assert 752)
|
|
(snd-cmd-time uint64 :offset-assert 760)
|
|
)
|
|
:method-count-assert 35
|
|
:size-assert #x300
|
|
:flag-assert #x2302800300
|
|
(:methods
|
|
(fac-robotank-method-32 () none) ;; 32
|
|
(fac-robotank-method-33 () none) ;; 33
|
|
(fac-robotank-method-34 () none) ;; 34
|
|
)
|
|
(:state-methods
|
|
turning ;; 28
|
|
moving ;; 29
|
|
pause ;; 30
|
|
die ;; 31
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fac-robotank-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern fac-robotank-post function)
|
|
;; (define-extern fac-robotank-handler function)
|
|
;; (define-extern fac-robotank-birth-path function)
|
|
;; (define-extern fac-robotank-init-by-other function)
|
|
;; (define-extern fac-robotank-spawn function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; factorya-init ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern factorya-login function)
|
|
;; (define-extern factorya-activate function)
|
|
;; (define-extern factorya-deactivate function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; mined-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype cav-airlock-door (com-airlock)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x1b0
|
|
:flag-assert #x1e013001b0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern prebot-darken function)
|
|
;; (define-extern scene-prebot-gun-spawn function)
|
|
;; (define-extern spt-birth-func-brightness-mine-boss-fma-dust-trailer function)
|
|
;; (define-extern spt-birth-func-brightness-mine-boss-fma-dust function)
|
|
;; (define-extern spt-birth-func-part-mine-boss-fma-dust function)
|
|
;; (define-extern spt-birth-func-part-mine-boss-fma-rocks function)
|
|
;; (define-extern spt-birth-func-part-mine-boss-fma-dust2 function)
|
|
;; (define-extern spt-birth-func-part-mine-boss-fma-rocks2 function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcanox-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype volcanox-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *volcanox-mood-color-table* object)
|
|
;; (define-extern *volcanox-mood-fog-table* object)
|
|
;; (define-extern update-mood-volcanox function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcanox-obs ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vol-holo-eye (process-drawable)
|
|
((eyeball-jmod joint-mod-set-world-no-trans :inline :offset-assert 204)
|
|
(other-eyeball-jmod joint-mod-set-world :inline :offset-assert 268)
|
|
(next-blink-time uint64 :offset-assert 332)
|
|
(trigger-radius float :offset-assert 340)
|
|
(idle-clock uint64 :offset-assert 348)
|
|
(actor-group uint32 :offset-assert 356)
|
|
(actor-group-count int32 :offset-assert 360)
|
|
(triggered? basic :offset-assert 364)
|
|
(untriggered? basic :offset-assert 368)
|
|
(kill-quat quaternion :inline :offset-assert 380)
|
|
(kill-angle float :offset-assert 396)
|
|
(kill-speed float :offset-assert 400)
|
|
(init-trans vector :inline :offset-assert 412)
|
|
(perm-part uint64 :offset-assert 428)
|
|
)
|
|
:method-count-assert 26
|
|
:size-assert #x1b8
|
|
:flag-assert #x1a014001b8
|
|
(:methods
|
|
(vol-holo-eye-method-25 () none) ;; 25
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
alert ;; 21
|
|
close ;; 22
|
|
die ;; 23
|
|
die-fast ;; 24
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype tpl-glider-broken (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
idle ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype dm-spines (process-drawable)
|
|
((alt-actor basic :offset-assert 200)
|
|
)
|
|
:method-count-assert 23
|
|
:size-assert #xcc
|
|
:flag-assert #x17005000cc
|
|
(:state-methods
|
|
open ;; 20
|
|
closed ;; 21
|
|
opening ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern sparticle-vol-holo-halo0 function)
|
|
;; (define-extern sparticle-vol-holo-halo1 function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcanox-scenes ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype monk-mummy (process-taskable)
|
|
()
|
|
:method-count-assert 40
|
|
:size-assert #x118
|
|
:flag-assert #x2800a00118
|
|
)
|
|
|#
|
|
|
|
;; (define-extern spt-birth-func-brightness-volcano-glider-dust function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcano-obs2 ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype vol-lava-plat (rigid-body-platform)
|
|
((anchor-point vector :inline :offset-assert 320)
|
|
(path-u float :offset-assert 336)
|
|
)
|
|
:method-count-assert 60
|
|
:size-assert #x154
|
|
:flag-assert #x3c00e00154
|
|
(:state-methods
|
|
active ;; 29
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-lava-plat-spawner (process)
|
|
((path basic :offset-assert 128)
|
|
)
|
|
:method-count-assert 15
|
|
:size-assert #x84
|
|
:flag-assert #xf00100084
|
|
(:state-methods
|
|
idle ;; 14
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-break-ground (process-drawable)
|
|
((ridden basic :offset-assert 200)
|
|
(ride-timer uint64 :offset-assert 208)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #xd8
|
|
:flag-assert #x18006000d8
|
|
(:methods
|
|
(vol-break-ground-method-23 () none) ;; 23
|
|
)
|
|
(:state-methods
|
|
idle ;; 20
|
|
active ;; 21
|
|
collapse ;; 22
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype vol-stone-lid (rigid-body-object)
|
|
((to-hole-vec vector :inline :offset-assert 288)
|
|
(hole basic :offset-assert 304)
|
|
(hole-dist-xz float :offset-assert 308)
|
|
(hole-dist-y float :offset-assert 312)
|
|
(hole-sync-norm float :offset-assert 316)
|
|
(lava-timer uint64 :offset-assert 320)
|
|
(stop-timer uint64 :offset-assert 328)
|
|
)
|
|
:method-count-assert 58
|
|
:size-assert #x150
|
|
:flag-assert #x3a00d00150
|
|
(:state-methods
|
|
idle ;; 28
|
|
active ;; 29
|
|
stopped ;; 56
|
|
die-and-respawn ;; 57
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *vol-lava-plat-platform-constants* object)
|
|
;; (define-extern vol-lava-plat-init-by-other function)
|
|
;; (define-extern *vol-stone-lid-rigid-body-constants* object)
|
|
;; (define-extern vol-stone-lid-init-by-other function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; volcano-mood ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype volcano-states (UNKNOWN)
|
|
()
|
|
:method-count-assert 0
|
|
:size-assert #x0
|
|
:flag-assert #x0
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *volcano-mood-color-table* object)
|
|
;; (define-extern *volcano-mood-fog-table* object)
|
|
;; (define-extern update-mood-volcano function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; spiky-frog ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype spiky-frog (nav-enemy)
|
|
((eye-jmod UNKNOWN 2 :offset-assert 620)
|
|
(roll-transform transformq :inline :offset-assert 640)
|
|
(time-out uint64 :offset-assert 688)
|
|
(sound-id uint32 :offset-assert 696)
|
|
)
|
|
:method-count-assert 199
|
|
:size-assert #x2bc
|
|
:flag-assert #xc7024002bc
|
|
(:methods
|
|
(spiky-frog-method-196 () none) ;; 196
|
|
(spiky-frog-method-197 () none) ;; 197
|
|
(spiky-frog-method-198 () none) ;; 198
|
|
)
|
|
(:state-methods
|
|
notice ;; 35
|
|
active ;; 34
|
|
pacing ;; 156
|
|
stare ;; 37
|
|
circling ;; 157
|
|
rolling-start ;; 190
|
|
hostile ;; 38
|
|
rolling ;; 191
|
|
rolling-stop ;; 192
|
|
turn ;; 195
|
|
attack ;; 193
|
|
attack-recover ;; 194
|
|
knocked ;; 31
|
|
knocked-recover ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *fact-info-spiky-frog-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *spiky-frog-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern spiky-frog-hop-slow-code function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; flamer-lava ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; flying-formation is already defined!
|
|
|
|
#|
|
|
(deftype flamer-lava (nav-enemy)
|
|
((shot-trajectory trajectory :inline :offset-assert 624)
|
|
(last-fire-time uint64 :offset-assert 664)
|
|
(sync-off uint32 :offset-assert 672)
|
|
(base-pos vector :inline :offset-assert 688)
|
|
(idle-pos vector :inline :offset-assert 704)
|
|
(offset vector :inline :offset-assert 720)
|
|
(dest-pos vector :inline :offset-assert 736)
|
|
(zone-to-world matrix :inline :offset-assert 752)
|
|
(world-to-zone matrix :inline :offset-assert 816)
|
|
(formation-entity basic :offset-assert 880)
|
|
(flit-joint joint-mod-set-local :inline :offset-assert 896)
|
|
(flit-angle float :offset-assert 960)
|
|
(flit-timer uint64 :offset-assert 968)
|
|
(path-pos float :offset-assert 976)
|
|
(sound-volume float :offset-assert 980)
|
|
(scale float :offset-assert 984)
|
|
(hit-surface? basic :offset-assert 988)
|
|
(ground-mode int8 :offset-assert 992)
|
|
(init-quat quaternion :inline :offset-assert 1008)
|
|
(surface-normal vector :inline :offset-assert 1024)
|
|
(main-joint-pos vector :inline :offset-assert 1040)
|
|
(main-joint-vel vector :inline :offset-assert 1056)
|
|
(main-joint-acc vector :inline :offset-assert 1072)
|
|
(main-acceleration float :offset-assert 1088)
|
|
(fly-dir vector :inline :offset-assert 1104)
|
|
)
|
|
:method-count-assert 205
|
|
:size-assert #x460
|
|
:flag-assert #xcd03e00460
|
|
(:methods
|
|
(flamer-lava-method-194 () none) ;; 194
|
|
(flamer-lava-method-195 () none) ;; 195
|
|
(flamer-lava-method-196 () none) ;; 196
|
|
(flamer-lava-method-197 () none) ;; 197
|
|
(flamer-lava-method-198 () none) ;; 198
|
|
(flamer-lava-method-199 () none) ;; 199
|
|
(flamer-lava-method-200 () none) ;; 200
|
|
(flamer-lava-method-201 () none) ;; 201
|
|
(flamer-lava-method-202 () none) ;; 202
|
|
(flamer-lava-method-203 () none) ;; 203
|
|
(flamer-lava-method-204 () none) ;; 204
|
|
)
|
|
(:state-methods
|
|
ambush ;; 47
|
|
wait-for-formation ;; 191
|
|
dormant ;; 28
|
|
dormant-aware ;; 29
|
|
exit-ambush-path ;; 193
|
|
idle ;; 33
|
|
active ;; 34
|
|
exit-ambush ;; 192
|
|
notice ;; 35
|
|
hostile ;; 38
|
|
attack ;; 190
|
|
knocked ;; 31
|
|
die-falling ;; 41
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype flaming-lava (flamer-lava)
|
|
()
|
|
:method-count-assert 205
|
|
:size-assert #x460
|
|
:flag-assert #xcd03e00460
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *flamer-lava-exploder-params* joint-exploder-static-params)
|
|
;; (define-extern *flamer-lava-fact-defaults* fact-info-enemy-defaults)
|
|
;; (define-extern *flamer-lava-nav-enemy-info* nav-enemy-info)
|
|
;; (define-extern flamer-lava-attack-post function)
|
|
;; (define-extern flamer-lava-flit-post function)
|
|
;; (define-extern flamer-lava-fly-code function)
|
|
;; (define-extern vector-square! function) ;; (function vector vector vector)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; protect-script ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype gunship-cmd (structure)
|
|
((command uint8 :offset-assert 0)
|
|
(spawn-type uint16 :offset-assert 2)
|
|
(count int8 :offset-assert 4)
|
|
(wait-type uint8 :offset-assert 2)
|
|
(difficulty float :offset-assert 8)
|
|
(wait-time uint64 :offset-assert 16)
|
|
(timeout-period uint64 :offset-assert 24)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x20
|
|
:flag-assert #x900000020
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gunship-cmd-context (structure)
|
|
((start-time uint64 :offset-assert 0)
|
|
(current-command gunship-cmd :inline :offset-assert 8)
|
|
(script basic :offset-assert 40)
|
|
(script-jump-point basic :offset-assert 44)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
;; (define-extern parse-protect-command function)
|
|
;; (define-extern *gunship-0-script* object)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; protect-path ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *protect-path* array)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; protect-gunship ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
#|
|
|
(deftype fire-missile-state (structure)
|
|
((missile-dest-positions UNKNOWN 16 :offset-assert 0)
|
|
(missile-handles UNKNOWN 16 :offset-assert 256)
|
|
(beacon-handles UNKNOWN 16 :offset-assert 384)
|
|
(last-fire-missile-time uint64 :offset-assert 512)
|
|
(last-probe-missile-time uint64 :offset-assert 520)
|
|
(launcher-rotate-time uint64 :offset-assert 528)
|
|
(num-missiles int8 :offset-assert 536)
|
|
(missile-launch-index int8 :offset-assert 537)
|
|
(missile-probe-index int8 :offset-assert 538)
|
|
(missile-shoot-index int8 :offset-assert 539)
|
|
(current-probe-angle float :offset-assert 540)
|
|
(probe-angle-shift float :offset-assert 544)
|
|
(difficulty-scalar float :offset-assert 548)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x228
|
|
:flag-assert #xa00000228
|
|
(:methods
|
|
(fire-missile-state-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gunship-info (structure)
|
|
((proc uint64 :offset-assert 0)
|
|
(want-target uint8 :offset-assert 8)
|
|
(cur-state basic :offset-assert 12)
|
|
(difficulty float :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x14
|
|
:flag-assert #x900000014
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gunship-movement-state (structure)
|
|
((state-time uint64 :offset-assert 0)
|
|
(next-update-time uint64 :offset-assert 8)
|
|
(cur-mode uint8 :offset-assert 16)
|
|
(dest-mode uint8 :offset-assert 17)
|
|
(dest-pos vector :inline :offset-assert 32)
|
|
(completed? basic :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x34
|
|
:flag-assert #x900000034
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gunship-spawn-info (structure)
|
|
((counts UNKNOWN 17 :offset-assert 0)
|
|
(next-spawn-time uint64 :offset-assert 24)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x20
|
|
:flag-assert #xa00000020
|
|
(:methods
|
|
(gunship-spawn-info-method-9 () none) ;; 9
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype protect-gunship (process-focusable)
|
|
((task-man uint64 :offset-assert 208)
|
|
(missile-info fire-missile-state :inline :offset-assert 224)
|
|
(stage-index int8 :offset-assert 776)
|
|
(num-stages int8 :offset-assert 777)
|
|
(hit-points float :offset-assert 780)
|
|
(last-attack-id uint32 :offset-assert 784)
|
|
(minimap connection-minimap :offset-assert 788)
|
|
(ground-pt vector :inline :offset-assert 800)
|
|
(basetrans vector :inline :offset-assert 816)
|
|
(move-state gunship-movement-state :inline :offset-assert 832)
|
|
(reaction-time uint64 :offset-assert 888)
|
|
(choose-new-point-time uint64 :offset-assert 896)
|
|
(chosen-point vector :inline :offset-assert 912)
|
|
(last-repo-pos vector :inline :offset-assert 928)
|
|
(suppress-times UNKNOWN 8 :offset-assert 944)
|
|
(want uint8 :offset-assert 1008)
|
|
(target uint8 :offset-assert 1009)
|
|
(spawn-info gunship-spawn-info :inline :offset-assert 1016)
|
|
(next-fire-missile-time uint64 :offset-assert 1048)
|
|
(next-spin-laser-time uint64 :offset-assert 1056)
|
|
(next-spawn-time uint64 :offset-assert 1064)
|
|
(last-land-time uint64 :offset-assert 1072)
|
|
(last-thrust-vec vector :inline :offset-assert 1088)
|
|
(roll-quat quaternion :inline :offset-assert 1104)
|
|
(difficulty float :offset-assert 1120)
|
|
(base-difficulty float :offset-assert 1124)
|
|
(land-start-hp float :offset-assert 1128)
|
|
(jmod-turret-twist joint-mod-rotate-local :inline :offset-assert 1136)
|
|
(jmod-turret-pitch joint-mod-rotate-local :inline :offset-assert 1168)
|
|
(jmod-doors UNKNOWN 4 :offset-assert 1200)
|
|
(open-doors uint8 :offset-assert 1328)
|
|
(num-open-doors uint8 :offset-assert 1329)
|
|
(last-door-index uint8 :offset-assert 1330)
|
|
(engines UNKNOWN 4 :offset-assert 1336)
|
|
(rotate-start-time uint64 :offset-assert 1368)
|
|
(rotate-total-time uint64 :offset-assert 1376)
|
|
(rotate-rate float :offset-assert 1384)
|
|
(laser-rotate-speed float :offset-assert 1388)
|
|
(current-laser-rotate-speed float :offset-assert 1392)
|
|
(base-laser-dir vector :inline :offset-assert 1408)
|
|
(next-new-laser-rot-time uint64 :offset-assert 1424)
|
|
(laser-y float :offset-assert 1432)
|
|
(jmod-laser-descend joint-mod-add-local :inline :offset-assert 1440)
|
|
(num-hp-per-stage float :offset-assert 1504)
|
|
(self-index int8 :offset-assert 1508)
|
|
(other-ship-index int8 :offset-assert 1509)
|
|
(attacker-info city-attacker-info :offset-assert 1512)
|
|
(difficulty-scalar float :offset-assert 1516)
|
|
(sound-engine-loop uint32 :offset-assert 1520)
|
|
(sound-lock-on uint32 :offset-assert 1524)
|
|
(sound-lock-on-hi uint32 :offset-assert 1528)
|
|
(alive-engines uint8 :offset-assert 1532)
|
|
(last-engine? basic :offset-assert 1536)
|
|
(desired-thruster-length float :offset-assert 1540)
|
|
(last-thrust vector :inline :offset-assert 1552)
|
|
(smoke-parts UNKNOWN 4 :offset-assert 1568)
|
|
)
|
|
:method-count-assert 58
|
|
:size-assert #x630
|
|
:flag-assert #x3a05b00630
|
|
(:methods
|
|
(protect-gunship-method-36 () none) ;; 36
|
|
(protect-gunship-method-37 () none) ;; 37
|
|
(protect-gunship-method-38 () none) ;; 38
|
|
(protect-gunship-method-39 () none) ;; 39
|
|
(protect-gunship-method-40 () none) ;; 40
|
|
(protect-gunship-method-41 () none) ;; 41
|
|
(protect-gunship-method-42 () none) ;; 42
|
|
(protect-gunship-method-43 () none) ;; 43
|
|
(protect-gunship-method-44 () none) ;; 44
|
|
(protect-gunship-method-45 () none) ;; 45
|
|
(protect-gunship-method-46 () none) ;; 46
|
|
(protect-gunship-method-47 () none) ;; 47
|
|
(protect-gunship-method-48 () none) ;; 48
|
|
(protect-gunship-method-49 () none) ;; 49
|
|
(protect-gunship-method-50 () none) ;; 50
|
|
(protect-gunship-method-51 () none) ;; 51
|
|
(protect-gunship-method-52 () none) ;; 52
|
|
(protect-gunship-method-53 () none) ;; 53
|
|
(protect-gunship-method-54 () none) ;; 54
|
|
(protect-gunship-method-55 () none) ;; 55
|
|
(protect-gunship-method-56 () none) ;; 56
|
|
(protect-gunship-method-57 () none) ;; 57
|
|
)
|
|
(:state-methods
|
|
die ;; 35
|
|
protect-gunship-base-state ;; 28
|
|
enemy-spawning ;; 33
|
|
spinning-laser ;; 34
|
|
hover ;; 29
|
|
landed ;; 30
|
|
raising ;; 31
|
|
lowering ;; 32
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gunship-engine (process-focusable)
|
|
((hit-points float :offset-assert 208)
|
|
(child-index int16 :offset-assert 212)
|
|
(last-attack-id uint32 :offset-assert 216)
|
|
(attacker-info city-attacker-info :offset-assert 220)
|
|
(bolt basic :offset-assert 224)
|
|
(hit-recently? basic :offset-assert 228)
|
|
(last-hit-time uint64 :offset-assert 232)
|
|
)
|
|
:method-count-assert 31
|
|
:size-assert #xf0
|
|
:flag-assert #x1f007000f0
|
|
(:methods
|
|
(gunship-engine-method-30 () none) ;; 30
|
|
)
|
|
(:state-methods
|
|
explode ;; 29
|
|
idle ;; 28
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype protect-gunship-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(task-man uint64 :offset-assert 32)
|
|
(script basic :offset-assert 40)
|
|
(num-stages int8 :offset-assert 44)
|
|
(self-index int8 :offset-assert 45)
|
|
(difficulty float :offset-assert 48)
|
|
(difficulty-scalar float :offset-assert 52)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x38
|
|
:flag-assert #x900000038
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype protect-gunship-enemy-spawn-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(spawn-type uint16 :offset-assert 32)
|
|
(parent uint64 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x30
|
|
:flag-assert #x900000030
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gunship-exploder (process-drawable)
|
|
()
|
|
:method-count-assert 21
|
|
:size-assert #xc8
|
|
:flag-assert #x15005000c8
|
|
(:state-methods
|
|
explode ;; 20
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gunship-missile (process-focusable)
|
|
((dest-pos vector :inline :offset-assert 208)
|
|
(launch-dir vector :inline :offset-assert 224)
|
|
(particle-trail basic :offset-assert 240)
|
|
(travel-speed float :offset-assert 244)
|
|
(attack-time float :offset-assert 248)
|
|
(attack-id uint32 :offset-assert 252)
|
|
(index int16 :offset-assert 256)
|
|
(swoosh-sound uint32 :offset-assert 260)
|
|
)
|
|
:method-count-assert 33
|
|
:size-assert #x108
|
|
:flag-assert #x2100900108
|
|
(:methods
|
|
(gunship-missile-method-31 () none) ;; 31
|
|
(gunship-missile-method-32 () none) ;; 32
|
|
)
|
|
(:state-methods
|
|
launch ;; 28
|
|
attack-targ ;; 29
|
|
explode ;; 30
|
|
)
|
|
)
|
|
|#
|
|
|
|
#|
|
|
(deftype gunship-missile-init-params (structure)
|
|
((pos vector :inline :offset-assert 0)
|
|
(dest-pos vector :inline :offset-assert 16)
|
|
(launch-dir vector :inline :offset-assert 32)
|
|
(time-to-targ float :offset-assert 48)
|
|
(index int16 :offset-assert 52)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x36
|
|
:flag-assert #x900000036
|
|
)
|
|
|#
|
|
|
|
;; (define-extern *gunship-nav-mesh* object)
|
|
;; (define-extern *range-ffexplo-dust-color* curve-color-fast)
|
|
;; (define-extern *range-ffexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *range-ffexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-alpha* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-ffexplo-dust-scale-y* curve2d-fast)
|
|
;; (define-extern *part-grp-gunship-explosion-dust-in-curve-settings* object)
|
|
;; (define-extern *range-gunship-explo-color* curve-color-fast)
|
|
;; (define-extern *range-gunship-explo-alpha* curve2d-fast)
|
|
;; (define-extern *range-gunship-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *range-gunship-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *curve-gunship-explo-alpha* curve2d-fast)
|
|
;; (define-extern *curve-gunship-explo-scale-x* curve2d-fast)
|
|
;; (define-extern *curve-gunship-explo-scale-y* curve2d-fast)
|
|
;; (define-extern *part-grp-gunship-explosion-texture-curve-settings* object)
|
|
;; (define-extern *active-gunships* object)
|
|
;; (define-extern *gunship-door-joints* array)
|
|
;; (define-extern *gunship-engine-segs-undamaged* array)
|
|
;; (define-extern *gunship-engine-segs-damaged* array)
|
|
;; (define-extern *gunship-engine-lightning* object)
|
|
;; (define-extern gunship-engine-init-by-other function)
|
|
;; (define-extern find-nearest-nav-mesh-protect function)
|
|
;; (define-extern gunship-event-handler function)
|
|
;; (define-extern *gunship-shadow-control* shadow-control)
|
|
;; (define-extern protect-gunship-init-by-other function)
|
|
;; (define-extern gunship-exploder-init-by-other function)
|
|
;; (define-extern gunship-missile-init-by-other function)
|
|
;; (define-extern *rand-missile-sound-list* array)
|
|
;; (define-extern *missile-launch-locations* array)
|
|
;; (define-extern find-reposition-pt function)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; deshover-texture ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; (define-extern *deshover-texture-anim-array* texture-anim-array)
|
|
;; (define-extern deshover-texture-anim-func function)
|
|
|
|
|