From 15a66d9c6250aebb560a1edcc1081420d4e52605 Mon Sep 17 00:00:00 2001 From: water Date: Sun, 25 Oct 2020 12:07:10 -0400 Subject: [PATCH 1/3] add types --- common/type_system/deftype.cpp | 8 +- decompiler/Function/TypeInspector.cpp | 123 +- decompiler/config/all-types.gc | 29084 +++++++++++++++- decompiler/config/jak1_ntsc_black_label.jsonc | 9 +- decompiler/util/DecompilerTypeSystem.cpp | 13 + 5 files changed, 29055 insertions(+), 182 deletions(-) diff --git a/common/type_system/deftype.cpp b/common/type_system/deftype.cpp index 1487640080..1ac8fbfad7 100644 --- a/common/type_system/deftype.cpp +++ b/common/type_system/deftype.cpp @@ -239,7 +239,13 @@ StructureDefResult parse_structure_def(StructureType* type, result.generate_runtime_type = false; } else if (opt_name == ":pack-me") { result.pack_me = true; - } else { + } else if (opt_name == ":heap-base") { + u16 hb = get_int(car(rest)); + rest = cdr(rest); + flags.heap_base = hb; + } + + else { throw std::runtime_error("Invalid option in field specification: " + opt_name); } } diff --git a/decompiler/Function/TypeInspector.cpp b/decompiler/Function/TypeInspector.cpp index a54e130eed..10dd9a3348 100644 --- a/decompiler/Function/TypeInspector.cpp +++ b/decompiler/Function/TypeInspector.cpp @@ -312,10 +312,13 @@ bool get_ptr_offset(IR* ir, Register dst, Register base, int* result) { get_ptr_offset_zero(as_math, base, result); } -bool is_weird(Function& function, LinkedObjectFile& file, TypeInspectorResult* result) { +int get_start_idx(Function& function, + LinkedObjectFile& file, + TypeInspectorResult* result, + const std::string& parent_type) { if (function.basic_blocks.size() > 1) { result->warnings += " too many basic blocks"; - return true; + return 0; } /* @@ -341,64 +344,94 @@ bool is_weird(Function& function, LinkedObjectFile& file, TypeInspectorResult* r // check size if (function.basic_ops.size() < 7) { result->warnings += " not enough basic ops"; - return true; + return 0; } auto& move_op = function.basic_ops.at(0); if (!is_reg_reg_move(move_op.get(), make_gpr(Reg::GP), make_gpr(Reg::A0))) { result->warnings += "bad first move"; - return true; + return 0; } auto& get_format_op = function.basic_ops.at(1); - if (!is_get_sym_value(get_format_op.get(), make_gpr(Reg::T9), "format")) { - result->warnings += "bad get format"; - return true; - } - auto& get_true = function.basic_ops.at(2); - if (!is_get_sym(get_true.get(), make_gpr(Reg::A0), "#t")) { - result->warnings += "bad get true"; - return true; - } + if (is_get_sym_value(get_format_op.get(), make_gpr(Reg::T9), "format")) { - auto& get_str = function.basic_ops.at(3); - if (!is_get_label(get_str.get(), make_gpr(Reg::A1))) { - result->warnings += "bad get label"; - return true; - } + auto& get_true = function.basic_ops.at(2); + if (!is_get_sym(get_true.get(), make_gpr(Reg::A0), "#t")) { + result->warnings += "bad get true"; + return 0; + } - auto str = file.get_goal_string_by_label(file.labels.at(get_label_id_of_set(get_str.get()))); - if (str != "[~8x] ~A~%") { - result->warnings += "bad type dec string: " + str; - return true; - } + auto& get_str = function.basic_ops.at(3); + if (!is_get_label(get_str.get(), make_gpr(Reg::A1))) { + result->warnings += "bad get label"; + return 0; + } - auto& move2_op = function.basic_ops.at(4); - if (!is_reg_reg_move(move2_op.get(), make_gpr(Reg::A2), make_gpr(Reg::GP))) { - result->warnings += "bad second move"; - return true; - } + auto str = file.get_goal_string_by_label(file.labels.at(get_label_id_of_set(get_str.get()))); + if (str != "[~8x] ~A~%") { + result->warnings += "bad type dec string: " + str; + return 0; + } - auto& load_op = function.basic_ops.at(5); - bool is_basic_load = is_get_load_with_offset(load_op.get(), make_gpr(Reg::A3), IR_Load::UNSIGNED, - 4, make_gpr(Reg::GP), -4); - result->is_basic = is_basic_load; + auto& move2_op = function.basic_ops.at(4); + if (!is_reg_reg_move(move2_op.get(), make_gpr(Reg::A2), make_gpr(Reg::GP))) { + result->warnings += "bad second move"; + return 0; + } - bool is_struct_load = is_get_sym(load_op.get(), make_gpr(Reg::A3), function.method_of_type); + auto& load_op = function.basic_ops.at(5); + bool is_basic_load = is_get_load_with_offset(load_op.get(), make_gpr(Reg::A3), + IR_Load::UNSIGNED, 4, make_gpr(Reg::GP), -4); + result->is_basic = is_basic_load; - if (!is_basic_load && !is_struct_load) { - result->warnings += "bad load"; - return true; - } + bool is_struct_load = is_get_sym(load_op.get(), make_gpr(Reg::A3), function.method_of_type); - auto& call = function.basic_ops.at(6); - if (!dynamic_cast(call.get())) { - result->warnings += "bad call"; - return true; - } + if (!is_basic_load && !is_struct_load) { + result->warnings += "bad load"; + return 0; + } + + auto& call = function.basic_ops.at(6); + if (!dynamic_cast(call.get())) { + result->warnings += "bad call"; + return 0; + } + + // okay! + return 7; + } else { + if (is_get_sym_value(get_format_op.get(), make_gpr(Reg::V1), parent_type)) { + // now get the inspect method. + auto& get_method_op = function.basic_ops.at(2); + if (!is_get_load_with_offset(get_method_op.get(), make_gpr(Reg::T9), IR_Load::UNSIGNED, 4, + make_gpr(Reg::V1), 28)) { + result->warnings += "bad get method op " + get_method_op->print(file); + return 0; + } + + auto& move2_op = function.basic_ops.at(3); + if (!is_reg_reg_move(move2_op.get(), make_gpr(Reg::A0), make_gpr(Reg::GP))) { + result->warnings += "bad move2 op " + move2_op->print(file); + return 0; + } + + auto& call_op = function.basic_ops.at(4); + if (!dynamic_cast(call_op.get())) { + result->warnings += "bad call op " + call_op->print(file); + return 0; + } + + result->warnings += "inherited inpspect of " + parent_type; + result->is_basic = true; + return 5; - return false; + } else { + result->warnings += "unrecognized get op: " + get_format_op->print(file) + " parent was " + parent_type; + return 0; + } + } } int identify_basic_field(int idx, @@ -706,11 +739,11 @@ TypeInspectorResult inspect_inspect_method(Function& inspect, assert(flags.pad == 0); auto& bad_set = get_config().bad_inspect_types; - if (is_weird(inspect, file, &result) || bad_set.find(type_name) != bad_set.end()) { + int idx = get_start_idx(inspect, file, &result, result.parent_type_name); + if (idx == 0 || bad_set.find(type_name) != bad_set.end()) { // printf("was weird: %s\n", result.warnings.c_str()); return result; } - int idx = 7; while (idx < int(inspect.basic_ops.size()) - 1 && idx != -1) { idx = detect(idx, inspect, file, &result); } diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc index 723aa61129..b1fa703274 100644 --- a/decompiler/config/all-types.gc +++ b/decompiler/config/all-types.gc @@ -6,13 +6,25 @@ ;; TYPES ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;; -;; gcommon -;;;;;;;;;;;;;; +; ;; gcommon +; (deftype array (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; too many basic blocks +; ) -;; todo array -;; todo vec4s +; ;; gcommon +; (deftype vec4s (uint128) +; () +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ;; likely a bitfield type +; ) +;; gcommon (deftype bfloat (basic) ((data float :offset-assert 4) ) @@ -21,25 +33,22 @@ :flag-assert #x900000008 ) +;; gcommon (deftype inline-array-class (basic) ((length int32 :offset-assert 4) (allocated-length int32 :offset-assert 8) - (data uint8 :dynamic :offset-assert 12) - (_pad uint8 4) + (data uint8 :dynamic :offset-assert 12) ;; might not be here... + (_pad uint8 4) ;; ??? ) - (:methods (new (symbol type int) _type_ 0) ;; we will override print later on. This is optional to include - ) + (:methods (new (symbol type int) _type_ 0)) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -;;;;;;;;;;;;;; ;; gkernel-h -;;;;;;;;;;;;;; - (deftype kernel-context (basic) ((prevent-from-run uint32 :offset-assert 4) (require-for-run uint32 :offset-assert 8) @@ -58,6 +67,10 @@ :flag-assert #x900000030 ) +(declare-type process basic) +(declare-type stack-frame basic) + +;; gkernel-h (deftype thread (basic) ((name basic :offset-assert 4) (process process :offset-assert 8) @@ -81,6 +94,7 @@ :flag-assert #xc00000028 ) +;; gkernel-h (deftype cpu-thread (thread) ((rreg uint64 8 :offset-assert 40) (freg float 6 :offset-assert 104) @@ -98,6 +112,7 @@ :flag-assert #xc00000080 ) +;; gkernel-h (deftype process-tree (basic) ((name basic :offset-assert 4) (mask uint32 :offset-assert 8) @@ -121,6 +136,7 @@ :no-runtime-type ) +;; gkernel (deftype process (process-tree) ((pool basic :offset-assert #x20) (status basic :offset-assert #x24) @@ -155,6 +171,7 @@ :no-runtime-type ;; already defined by kscheme. Don't do it again. ) +;; gkernel-h (deftype dead-pool (process-tree) ( ;; nothing new! @@ -168,6 +185,7 @@ :flag-assert #x1000000020 ) +;; gkernel-h (deftype dead-pool-heap-rec (structure) ((process process :offset-assert 0) (prev dead-pool-heap-rec :offset-assert 4) @@ -179,6 +197,7 @@ :flag-assert #x90000000c ) +;; gkernel-h (deftype dead-pool-heap (dead-pool) ((allocated-length int32 :offset-assert 32) (compact-time uint32 :offset-assert 36) @@ -241,8 +260,18 @@ :size-assert #x10 :flag-assert #x900000010 ) -;; todo handle +;; gkernel-h +;; todo +; (deftype handle (uint64) +; () +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ;; likely a bitfield type +; ) + +;; gkernel-h (deftype state (protect-frame) ((code function :offset-assert 16) (trans function :offset-assert 20) @@ -255,6 +284,7 @@ :flag-assert #x900000024 ) +;; gkernel-h (deftype event-message-block (structure) ((to basic :offset-assert 0) (from basic :offset-assert 4) @@ -267,10 +297,8 @@ :flag-assert #x900000048 ) -;;;;;;;;;;;;;; -;; pskernel -;;;;;;;;;;;;;; +;; pskernel (deftype lowmemmap (structure) ((irq-info-stack uint32 :offset-assert 0) (irq2-info-stack uint32 :offset-assert 4) @@ -292,10 +320,9 @@ :flag-assert #x900000044 ) -;;;;;;;;;;;;;; -;; dgo-h -;;;;;;;;;;;;;; + +;; dgo-h (deftype dgo-entry (structure) ((offset uint32 :offset-assert 0) (length uint32 :offset-assert 4) @@ -305,6 +332,7 @@ :flag-assert #x900000008 ) +;; dgo-h (deftype dgo-file (basic) ((num-go-files uint32 :offset-assert 4) (total-length uint32 :offset-assert 8) @@ -316,10 +344,7 @@ :flag-assert #x900000010 ) -;;;;;;;;;;;;;; ;; math -;;;;;;;;;;;;;; - (deftype random-generator (basic) ((seed uint32 :offset-assert 4) ) @@ -328,11 +353,7 @@ :flag-assert #x900000008 ) -;;;;;;;;;;;;;; -;; vector-h -;;;;;;;;;;;;;; - -;; note - this one has two inspect methods +; ;; vector-h (deftype vector (structure) ((data float 4 :offset-assert 0) (x float :offset 0) @@ -346,6 +367,7 @@ :flag-assert #x900000010 ) +;; vector-h (deftype bit-array (basic) ((length int32 :offset-assert 4) (allocated-length int32 :offset-assert 8) @@ -370,6 +392,7 @@ (w uint8 :offset 3) (clr uint32 :offset 0) ) + :pack-me :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 @@ -403,6 +426,7 @@ (y uint16 :offset 2) (val uint32 :offset 0) ) + :pack-me :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 @@ -424,6 +448,7 @@ (x int32 :offset 0) (y int32 :offset 4) ) + :pack-me :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 @@ -613,6 +638,7 @@ ) ) +;; vector-h (deftype vertical-planes (structure) ((data uint128 4 :offset-assert 0) ;; probably wrong ) @@ -658,11 +684,7 @@ ) - -;;;;;;;;;;;;;;;;;;; ;; bounding-box-h -;;;;;;;;;;;;;;;;;;; - (deftype bounding-box (structure) ((min vector :inline :offset-assert 0) (max vector :inline :offset-assert 16) @@ -681,6 +703,7 @@ ) ) +;; bounding-box-h (deftype bounding-box4w (structure) ((min vector4w :inline :offset-assert 0) (max vector4w :inline :offset-assert 16) @@ -690,6 +713,7 @@ :flag-assert #x900000020 ) +;; bounding-box-h (deftype bounding-box-both (structure) ((box bounding-box :inline :offset-assert 0) (box4w bounding-box4w :inline :offset-assert 32) @@ -699,10 +723,7 @@ :flag-assert #x900000040 ) -;;;;;;;;;;;;;;;;;;; ;; matrix-h -;;;;;;;;;;;;;;;;;;; - (deftype matrix (structure) ((data float 16 :offset-assert 0) (vector vector 4 :offset 0) @@ -737,10 +758,6 @@ :flag-assert #x900000020 ) -;;;;;;;;;;;;;;;;;;; -;; quaternion-h -;;;;;;;;;;;;;;;;;;; - (deftype quaternion (structure) ((data float 4 :offset-assert 0) (x float :offset 0) @@ -755,10 +772,7 @@ :flag-assert #x900000010 ) -;;;;;;;;;;;;;;;;;;; ;; euler-h -;;;;;;;;;;;;;;;;;;; - (deftype euler-angles (vector) () :method-count-assert 9 @@ -766,34 +780,29 @@ :flag-assert #x900000010 ) -;;;;;;;;;;;;;;;;;;; ;; transform-h -;;;;;;;;;;;;;;;;;;; - (deftype transform (structure) ((trans vector :inline :offset-assert 0) - (rot vector :inline :offset-assert 16) ;; maybe 3 if euler - (scale vector :inline :offset-assert 32) ;; maybe 3 + (rot vector :inline :offset-assert 16) + (scale vector :inline :offset-assert 32) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) +;; transform-h (deftype trs (basic) ((trans vector :inline :offset-assert 16) - (rot vector :inline :offset-assert 32) ;; maybe 3 if euler - (scale vector :inline :offset-assert 48) ;; maybe 3 + (rot vector :inline :offset-assert 32) + (scale vector :inline :offset-assert 48) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -;;;;;;;;;;;;;;;;;;; ;; geometry-h -;;;;;;;;;;;;;;;;;;; - (deftype curve (structure) ((cverts uint32 :offset-assert 0) (num-cverts int32 :offset-assert 4) @@ -806,6 +815,7 @@ :flag-assert #x900000014 ) +;; geometry-h (deftype border-plane (basic) ((name basic :offset-assert 4) (action basic :offset-assert 8) @@ -822,10 +832,7 @@ ) ) -;;;;;;;;;;;;;;;;;;; -;; transformq-h -;;;;;;;;;;;;;;;;;;; - +; ;; transformq-h (deftype transformq (transform) ((quat quaternion :inline :offset 16) ) @@ -842,6 +849,8 @@ :flag-assert #x900000040 ) + +;; transformq-h (deftype trsqv (trsq) ((pause-adjust-distance float :offset 4) ;; todo meters (nav-radius float :offset 8) ;; todo meters @@ -878,10 +887,6 @@ ) ) -;;;;;;;;;;;;;;;;;;; -;; gsound-h -;;;;;;;;;;;;;;;;;;; - (deftype sound-rpc-cmd (structure) ((rsvd1 uint16 :offset-assert 0) (command uint16 :offset-assert 2) @@ -1264,9 +1269,16 @@ ;; vif-h ;;;;;;;;;;;;; -;; todo vif-stat +; ;; vif-h +; (deftype vif-stat (uint32) +; () +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ;; likely a bitfield type +; ) -;; these are spaced strangely, is this some HW map? +;; vif-h (deftype vif-bank (structure) ((stat uint32 :offset-assert 0) (fbrst uint32 :offset 16) @@ -1296,12 +1308,14 @@ :size-assert #x174 :flag-assert #x900000174 ) - -;;;;;;;;;;;;; -;; dma-h -;;;;;;;;;;;;; - -;; todo dma-chcr +; ;; dma-h +; (deftype dma-chcr (uint32) +; () +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ;; likely a bitfield type +; ) (deftype dma-bank (structure) ((chcr uint32 :offset 0) @@ -1365,7 +1379,16 @@ :flag-assert #x900000014 ) -;; todo dma-tag +; ;; dma-h +; (deftype dma-tag (uint64) +; () +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ;; likely a bitfield type +; ) + +; ;; dma-h (deftype dma-bucket (structure) ((tag uint64 :offset-assert 0) (last uint32 :offset-assert 8) @@ -1376,13 +1399,16 @@ :size-assert #x10 :flag-assert #x900000010 ) +; ;; dma-h +; (deftype vif-tag (uint32) +; () +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ;; likely a bitfield type +; ) -;; todo vif-tag - -;;;;;;;;;;;;; -;; video-h -;;;;;;;;;;;;; - +; ;; video-h (deftype video-parms (structure) ((set-video-mode basic :offset-assert 0) (reset-video-mode basic :offset-assert 4) @@ -1406,10 +1432,7 @@ :flag-assert #x900000048 ) -;;;;;;;;;;;;;;; ;; vu1-user-h -;;;;;;;;;;;;;;; - (deftype dma-foreground-sink (basic) ((bucket int32 :offset-assert 4) (foreground-texture-page int8 :offset-assert 8) @@ -1586,7 +1609,32 @@ :flag-assert #x900001048 ) -;; todo gs-alpha, gs-fog, gs-fogcol +; ;; gs +; (deftype gs-alpha (uint64) +; () +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ;; likely a bitfield type +; ) + +; ;; gs +; (deftype gs-fog (uint64) +; () +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ;; likely a bitfield type +; ) + +; ;; gs +; (deftype gs-fogcol (uint64) +; () +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ;; likely a bitfield type +; ) (deftype gif-bank (structure) ((ctrl uint32 :offset 0) @@ -1617,7 +1665,15 @@ :flag-assert #x900000010 ) -;; todo gif-tag +; ;; gs +; (deftype gif-tag (uint128) +; () +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ;; bad type dec string: [~8x] gif-tag~% +; ) + (deftype gif-packet (basic) ((reg-count int32 :offset-assert 4) (gif-tag0 uint128 :offset-assert 16) @@ -1709,56 +1765,58 @@ :flag-assert #x900000014 ) -;; todo -; (deftype display (basic) -; ((display-env0 display-env :inline :offset-assert 8) -; (display-env1 display-env :inline :offset-assert 48) -; (display-env2 display-env :inline :offset-assert 88) -; (gif-tag0 uint128 :offset-assert 128) -; (draw0 draw-env :inline :offset-assert 144) -; (gif-tag1 uint128 :offset-assert 272) -; (draw1 draw-env :inline :offset-assert 288) -; (gif-tag2 uint128 :offset-assert 416) -; (draw2 draw-env :inline :offset-assert 432) -; (on-screen int32 :offset-assert 560) -; (last-screen int32 :offset-assert 564) -; (frames UNKNOWN 6 :offset-assert 568) -; (bg-clear-color UNKNOWN 4 :offset-assert 760) -; (real-frame-counter uint64 :offset-assert 776) -; (base-frame-counter uint64 :offset-assert 784) -; (game-frame-counter uint64 :offset-assert 792) -; (integral-frame-counter uint64 :offset-assert 800) -; (real-integral-frame-counter uint64 :offset-assert 808) -; (actual-frame-counter uint64 :offset-assert 816) -; (real-actual-frame-counter uint64 :offset-assert 824) -; (part-frame-counter uint64 :offset-assert 832) -; (old-real-frame-counter uint64 :offset-assert 840) -; (old-base-frame-counter uint64 :offset-assert 848) -; (old-game-frame-counter uint64 :offset-assert 856) -; (old-integral-frame-counter uint64 :offset-assert 864) -; (old-real-integral-frame-counter uint64 :offset-assert 872) -; (old-actual-frame-counter uint64 :offset-assert 880) -; (old-real-actual-frame-counter uint64 :offset-assert 888) -; (old-part-frame-counter uint64 :offset-assert 896) -; (time-ratio float :offset-assert 904) -; (seconds-per-frame float :offset-assert 908) -; (frames-per-second float :offset-assert 912) -; (time-factor float :offset-assert 916) -; (time-adjust-ratio float :offset-assert 920) -; ) -; :method-count-assert 10 -; :size-assert #x39c -; :flag-assert #xa0000039c -; (:methods -; (dummy-9 () none 9) -; ) -; ) +;; display-h +(deftype display (basic) + ((display-env0 display-env :inline :offset-assert 8) + (display-env1 display-env :inline :offset-assert 48) + (display-env2 display-env :inline :offset-assert 88) + (gif-tag0 uint128 :offset-assert 128) + (draw0 draw-env :inline :offset-assert 144) + (gif-tag1 uint128 :offset-assert 272) + (draw1 draw-env :inline :offset-assert 288) + (gif-tag2 uint128 :offset-assert 416) + (draw2 draw-env :inline :offset-assert 432) + (on-screen int32 :offset-assert 560) + (last-screen int32 :offset-assert 564) + ;(frames UNKNOWN 6 :offset-assert 568) + (_frames-pad uint8 196) + ;(bg-clear-color UNKNOWN 4 :offset-assert 760) + (_bg-clear-color-pad uint8 8) + (real-frame-counter uint64 :offset-assert 776) + (base-frame-counter uint64 :offset-assert 784) + (game-frame-counter uint64 :offset-assert 792) + (integral-frame-counter uint64 :offset-assert 800) + (real-integral-frame-counter uint64 :offset-assert 808) + (actual-frame-counter uint64 :offset-assert 816) + (real-actual-frame-counter uint64 :offset-assert 824) + (part-frame-counter uint64 :offset-assert 832) + (old-real-frame-counter uint64 :offset-assert 840) + (old-base-frame-counter uint64 :offset-assert 848) + (old-game-frame-counter uint64 :offset-assert 856) + (old-integral-frame-counter uint64 :offset-assert 864) + (old-real-integral-frame-counter uint64 :offset-assert 872) + (old-actual-frame-counter uint64 :offset-assert 880) + (old-real-actual-frame-counter uint64 :offset-assert 888) + (old-part-frame-counter uint64 :offset-assert 896) + (time-ratio float :offset-assert 904) + (seconds-per-frame float :offset-assert 908) + (frames-per-second float :offset-assert 912) + (time-factor float :offset-assert 916) + (time-adjust-ratio float :offset-assert 920) + ) + :method-count-assert 10 + :size-assert #x39c + :flag-assert #xa0000039c + (:methods + (dummy-9 () none 9) + ) + ) ;;;;;;;;;;;;;;; ;; file-io ;;;;;;;;;;;;;;; -;; todo, builtin type issue +;; todo ; (deftype file-stream (basic) ; ((flags uint32 :offset-assert 4) ; (mode basic :offset-assert 8) @@ -1836,11 +1894,11 @@ ) ;; loader-h -; todo inline basics missing offset?? +;; todo inline basics ; (deftype external-art-control (basic) ; ((buffer basic 2 :offset-assert 4) -; ;(rec basic 3 :offset-assert 20) some inline structure -; (_pad uint8 142) +; ;(rec UNKNOWN 3 :offset-assert 20) +; (_rec-pad uint8 142) ; (spool-lock uint64 :offset-assert 160) ; (reserve-buffer basic :offset-assert 168) ; (reserve-buffer-count int32 :offset-assert 172) @@ -1867,10 +1925,15 @@ ;; texture-h ;;;;;;;;;;;;;; -;; texture-h -;; todo texture-id +; ;; texture-h +; (deftype texture-id (uint32) +; () +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ;; likely a bitfield type +; ) -;; texture-h (deftype texture-pool-segment (structure) ((dest uint32 :offset-assert 0) (size uint32 :offset-assert 4) @@ -2036,7 +2099,6 @@ :size-assert #x10 :flag-assert #x900000010 ) - ;;;;;;;;;;;;;; ;; level-h ;;;;;;;;;;;;;; @@ -2108,7 +2170,6 @@ :size-assert #x50 :flag-assert #x900000050 ) - ; ;; level-h ; (deftype level (basic) ; ((name basic :offset-assert 4) @@ -2220,6 +2281,28765 @@ ; ) ; ) +;;;;;;;;;;;;;;;;;; +;; 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 + ) + +;; math-camera-h +(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) + ) + :pack-me + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +(deftype math-camera (basic) + ((d float :offset-assert 4) ;; meters + (f float :offset-assert 8) ;; meters + (fov float :offset-assert 12) ;; deg + (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 float :offset-assert 120) ;; meters + (fog-end float :offset-assert 124) ;; meters + (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) + (hmge-scale vector :inline :offset-assert 704) + (inv-hmge-scale vector :inline :offset-assert 720) + (hvdf-off vector :inline :offset-assert 736) + (guard vector :inline :offset-assert 752) + (vis-gifs uint128 4 :offset-assert 768) + (giftex uint128 :offset 768) + (gifgr uint128 :offset 784) + (giftex-trans uint128 :offset 800) + (gifgr-trans uint128 :offset 816) + (pfog0 float :offset-assert 832) + (pfog1 float :offset-assert 836) + (trans vector :inline :offset-assert 848) + (plane uint128 4 :offset-assert 864) + (guard-plane uint128 4 :offset-assert 928) + (shrub-mat matrix :inline :offset-assert 992) + (fov-correction-factor float :offset-assert 1056) + ) + :method-count-assert 9 + :size-assert #x424 + :flag-assert #x900000424 + ) + +(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 + ) + +;;;;;;;;;;; +;; font-h +;;;;;;;;;;; + +(deftype char-verts (structure) + ((pos uint128 4 :offset-assert 0) + (color uint128 4 :offset-assert 64) + (tex-st uint128 4 :offset-assert 128) + ) + :method-count-assert 9 + :size-assert #xc0 + :flag-assert #x9000000c0 + ) + +(deftype char-color (structure) + ((color uint32 4 :offset-assert 0) + ) + :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) + (color uint64 :offset-assert 64) + (flags uint32 :offset-assert 72) + (mat matrix :offset-assert 76) + (start-line uint32 :offset-assert 80) + (scale float :offset-assert 84) + ) + :method-count-assert 20 + :size-assert #x58 + :flag-assert #x1400000058 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + ) + ) + +(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) + (small-font-lo-tmpl uint64 2 :offset-assert 80) + (small-font-hi-tmpl uint64 2 :offset-assert 96) + (large-font-lo-tmpl uint64 2 :offset-assert 112) + (large-font-hi-tmpl uint64 2 :offset-assert 128) + (size1-small vector :inline :offset-assert 144) + (size2-small vector :inline :offset-assert 160) + (size3-small vector :inline :offset-assert 176) + (size1-large vector :inline :offset-assert 192) + (size2-large vector :inline :offset-assert 208) + (size3-large vector :inline :offset-assert 224) + (size-st1 vector :inline :offset-assert 240) + (size-st2 vector :inline :offset-assert 256) + (size-st3 vector :inline :offset-assert 272) + (save vector :inline :offset-assert 288) + (save-color uint128 4 :offset-assert 304) + (current-verts char-verts :inline :offset-assert 368) + (src-verts char-verts :inline :offset-assert 560) + (dest-verts char-verts :inline :offset-assert 752) + (justify uint128 64 :offset-assert 944) + (color-shadow vector4w :inline :offset-assert 1968) + (color-table uint128 64 :offset-assert 1984) + (last-color uint64 :offset-assert 3008) + (save-last-color uint64 :offset-assert 3016) + (buf basic :offset-assert 3024) + (str-ptr uint32 :offset-assert 3028) + (flags uint32 :offset-assert 3032) + (reg-save uint32 5 :offset-assert 3036) + ) + :method-count-assert 9 + :size-assert #xbf0 + :flag-assert #x900000bf0 + ) + +;;;;;;;;;;;;; +;; decomp-h +;;;;;;;;;;;;; + +(deftype decomp-work (structure) + ((buffer0 uint8 2048 :offset-assert 0) + (buffer1 uint8 2048 :offset-assert 2048) + (indices uint16 2048 :offset-assert 4096) + (temp-indices uint16 2048 :offset-assert 8192) + ) + :method-count-assert 9 + :size-assert #x3000 + :flag-assert #x900003000 + ) + +;;;;;;;;;;;;; +;; 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 basic :offset-assert 24) + (param3 basic :offset-assert 28) + (quad uint128 2 :offset 0) + ) + :method-count-assert 14 + :size-assert #x20 + :flag-assert #xe00000020 + ;; field param1 is a basic loaded with a signed load field param2 is a basic loaded with a signed load field param3 is a basic loaded with a signed load + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + ) + ) + +; ;; connect +; (deftype engine (basic) +; () +; :method-count-assert 24 +; :size-assert #x80 +; :flag-assert #x1800000080 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +;;;;;;;;;;;;;;;; +;; text-h +;;;;;;;;;;;;;;;; + +(deftype game-text (structure) + ((id uint32 :offset-assert 0) + (text basic :offset-assert 4) + ) + :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 basic :offset-assert 12) + (data uint8 :dynamic :offset-assert 16) + ) + :method-count-assert 10 + :size-assert #x10 + :flag-assert #xa00000010 + (:methods + (dummy-9 () none 9) + ) + ) + +;;;;;;;;;;;;;;;; +;; settings-h +;;;;;;;;;;;;;;;; + +; ;; settings-h +; (deftype setting-data (structure) +; () +; :method-count-assert 10 +; :size-assert #xc4 +; :flag-assert #xa000000c4 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; settings-h +; (deftype setting-control (basic) +; ((current setting-data :inline :offset-assert 16) +; (target setting-data :inline :offset-assert 224) +; (default setting-data :inline :offset-assert 432) +; (engine basic :offset-assert 628) +; ) +; :method-count-assert 14 +; :size-assert #x278 +; :flag-assert #xe00000278 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +(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 + ) + + +;;;;;;;;;;;;;;;;; +;; capture +;;;;;;;;;;;;;;;;; + +(deftype gs-store-image-packet (structure) + ((vifcode uint32 4 :offset-assert 0) + (giftag uint128 :offset-assert 16) + (bitbltbuf uint64 :offset-assert 32) + (bitbltbuf-addr uint64 :offset-assert 40) + (trxpos uint64 :offset-assert 48) + (trxpos-addr uint64 :offset-assert 56) + (trxreg uint64 :offset-assert 64) + (trxreg-addr uint64 :offset-assert 72) + (finish uint64 :offset-assert 80) + (finish-addr uint64 :offset-assert 88) + (trxdir uint64 :offset-assert 96) + (trxdir-addr uint64 :offset-assert 104) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) + +;;;;;;;;;;;;;;;;;; +;; memory-usage-h +;;;;;;;;;;;;;;;;;; + +(deftype memory-usage-info (structure) + ((name basic :offset-assert 0) + (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 109 :inline :offset-assert 16) ;; guess + ) + :method-count-assert 12 + :size-assert #x6e0 + :flag-assert #xc000006e0 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + ) + ) + +;;;;;;;;;;;;;; +;; texture +;;;;;;;;;;;;;; + +; ;; texture +; (deftype texture-page-dir (basic) +; () +; :method-count-assert 10 +; :size-assert #x14 +; :flag-assert #xa00000014 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +;;;;;;;;;;;;;; +;; main-h +;;;;;;;;;;;;;; + +(deftype frame-stats (structure) + ((field-time uint64 2 :offset-assert 0) + (field int32 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) + +(deftype screen-filter (basic) + ((draw? basic :offset-assert 4) + (color uint32 :offset-assert 8) + ) + :method-count-assert 10 + :size-assert #xc + :flag-assert #xa0000000c + (:methods + (dummy-9 () none 9) + ) + ) + +;;;;;;;;;;;;;; +;; mspace-h +;;;;;;;;;;;;;; + +(deftype joint (basic) + ((name basic :offset-assert 4) + (number int32 :offset-assert 8) + (parent basic :offset-assert 12) + (bind-pose matrix :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + +;; mspace-h +(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 + ) + +;; mspace-h +(deftype bone (structure) + ((transform matrix :inline :offset-assert 0) + (position vector :inline :offset 48) ;; overlays the matrix + (scale vector :inline :offset-assert 64) + (cache bone-cache :inline :offset-assert 80) + ) + :method-count-assert 9 + :size-assert #x60 + :flag-assert #x900000060 + ) + +;; mspace-h +(deftype skeleton (inline-array-class) + () + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; mspace-h +(deftype cspace (structure) + ((parent cspace :offset-assert 0) + (joint basic :offset-assert 4) + (joint-num int16 :offset-assert 8) + (geo basic :offset-assert 12) + (bone bone :offset-assert 16) + (param0 basic :offset-assert 20) + (param1 basic :offset-assert 24) + (param2 basic :offset-assert 28) + ) + :method-count-assert 10 + :size-assert #x20 + :flag-assert #xa00000020 + ;; field param1 is a basic loaded with a signed load field param2 is a basic loaded with a signed load + (:methods + (dummy-9 () none 9) + ) + ) + +;; mspace-h +(deftype cspace-array (inline-array-class) + () + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;;;;;;;;;;;;;;; +;; drawable-h +;;;;;;;;;;;;;;; + +;; drawable-h +(deftype drawable (basic) + ((id int16 :offset-assert 4) + (bsphere vector :inline :offset-assert 16) + ) + :method-count-assert 18 + :size-assert #x20 + :flag-assert #x1200000020 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) + +;; drawable-h +(deftype drawable-error (drawable) + ((name basic :offset-assert 32) + ) + :method-count-assert 18 + :size-assert #x24 + :flag-assert #x1200000024 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; drawable-inline-array-h +;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(deftype drawable-inline-array (drawable) + ((length int16 :offset 6) ;; this is kinda weird. + ) + :method-count-assert 18 + :size-assert #x20 + :flag-assert #x1200000020 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) + +;;;;;;;;;;;;;;; +;; draw-node-h +;;;;;;;;;;;;;;; + +(deftype draw-node (drawable) + ((child-count uint8 :offset 6) + (flags uint8 :offset 7) + (child uint32 :offset 8) + (distance float :offset 12) + ) + :method-count-assert 18 + :size-assert #x20 + :flag-assert #x1200000020 + ;; field distance is a float printed as hex? + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) + +; ;; draw-node-h +; (deftype draw-node-dma (structure) +; ((banka UNKNOWN 32 :offset-assert 4) +; (bankb UNKNOWN 32 :offset-assert 1028) +; ) +; :method-count-assert 9 +; :size-assert #x800 +; :flag-assert #x900000800 +; ) + +;;;;;;;;;;;;;;;;;;;;; +;; drawable-actor-h +;;;;;;;;;;;;;;;;;;;;; + +(deftype drawable-actor (drawable) + ((actor basic :offset 8) + ) + :method-count-assert 18 + :size-assert #x20 + :flag-assert #x1200000020 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) + +;;;;;;;;;;;;;;;;;;;;;; +;; drawable-ambient-h +;;;;;;;;;;;;;;;;;;;;;; + +;; drawable-ambient-h +(deftype drawable-ambient (drawable) + ((ambient basic :offset 8) + ) + :method-count-assert 19 + :size-assert #x20 + :flag-assert #x1300000020 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + ) + ) + +;; drawable-ambient-h +(deftype level-hint (process) + ((text-id-to-display uint32 :offset-assert 112) + (sound-to-play basic :offset-assert 116) + (trans vector :offset-assert 120) + (sound-id uint32 :offset-assert 124) + (mode basic :offset-assert 128) + (total-time uint64 :offset-assert 136) + (total-off-time uint64 :offset-assert 144) + (last-time uint64 :offset-assert 152) + (voicebox uint64 :offset-assert 160) + ) + :heap-base #x40 + :method-count-assert 16 + :size-assert #xa8 + :flag-assert #x10004000a8 + ;; inherited inpspect of process + (:methods + (dummy-14 () none 14) + (dummy-15 () none 15) + ) + ) + + +; ;; drawable-ambient-h +(deftype ambient-list (structure) + ((num-items int32 :offset-assert 0) + (items uint32 2048 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x2004 + :flag-assert #x900002004 + ) + +;;;;;;;;;;;;;;;;;; +;; hint-control-h +;;;;;;;;;;;;;;;;;; + +;; hint-control-h +(deftype level-hint-control (structure) + ((delay-before-playing uint64 :offset-assert 0) + (id uint32 :offset-assert 8) + (num-attempts-before-playing int8 :offset-assert 12) + (num-success-before-killing int8 :offset-assert 13) + (num-attempts int8 :offset-assert 14) + (num-success int8 :offset-assert 15) + (start-time uint64 :offset-assert 16) + (last-time-called uint64 :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; hint-control-h +(deftype task-hint-control (structure) + ((task uint8 :offset-assert 0) + (delay uint64 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; hint-control-h +(deftype task-hint-control-group (structure) + ((tasks basic :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + + +;;;;;;;;;;;;;;;; +;; generic-h +;;;;;;;;;;;;;;;; + +;; todo +(deftype gsf-vertex (structure) + ((data uint32 8 :offset-assert 0) + (byte uint8 32 :offset 0) + (quad uint128 2 :offset 0) + (vt qword :inline :offset 0) + (pos vector3s :inline :offset 0) + (tex vector2uh :inline :offset 12) + (nrm vector3s :inline :offset 16) + (nc qword :inline :offset 16) + (clr vector4ub :inline :offset 28) + (dtex vector2uh :inline :offset 16) + (dclr vector4ub :inline :offset 20) + ) + :pack-me + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +; ;; generic-h +; (deftype gsf-vertex-array (UNKNOWN) +; ((vtx UNKNOWN :dynamic :offset-assert 0) +; ) +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ) + +; ;; generic-h +(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 + ) + + +; ;; generic-h +; (deftype gsf-fx-vertex-array (UNKNOWN) +; ((data UNKNOWN :dynamic :offset-assert 0) +; ) +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ) + +; ;; generic-h +(deftype gsf-header (structure) + ((num-strips uint8 :offset-assert 0) + (expanded uint8 :offset-assert 1) + (num-dps uint16 :offset-assert 2) + (num-vtxs uint16 :offset-assert 4) + (strip-table uint8 10 :offset-assert 6) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; generic-h +(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 + ) + +;; generic-h +(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 + ) + +;; generic-h +(deftype gsf-buffer (structure) + ((data uint8 8192 :offset-assert 0) + (info gsf-info :inline :offset 0) + (header gsf-header :inline :offset 16) + (work-area uint8 :dynamic :offset 32) + ) + :method-count-assert 9 + :size-assert #x2000 + :flag-assert #x900002000 + ) + +;; generic-h +(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 + ) + +;; generic-h +(deftype generic-strip (structure) + ((pos uint16 :offset-assert 0) + (len uint16 :offset-assert 2) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +;; generic-h +(deftype generic-envmap-saves (structure) + ((index-mask vector4w :inline :offset-assert 0) + (verts uint128 12 :offset-assert 16) + (kicks uint128 4 :offset-assert 208) + ) + :method-count-assert 9 + :size-assert #x110 + :flag-assert #x900000110 + ) + +;; generic-h +(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 + ) + +;; generic-h +(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 uint32 :offset-assert 56) + (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 uint32 :offset-assert 80) + (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 + ) + +;; generic-h +(deftype generic-gif-tag (structure) + ((data uint32 4 :offset-assert 0) + (qword qword :inline :offset 0) + (fan-prim uint32 :offset 0) + (str-prim uint32 :offset 4) + (regs uint32 :offset 8) + (num-strips uint32 :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; generic-h +(deftype ad-cmd (structure) + ((word uint32 4 :offset-assert 0) + (quad uint128 :offset 0) + (data uint64 :offset 0) + (cmds uint64 :offset 8) + (cmd uint8 :offset 8) + (x uint32 :offset 0) + (y uint32 :offset 4) + (z uint32 :offset 8) + (w uint32 :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; generic-h +(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 + ) + +;; generic-h +(deftype generic-consts (structure) + ((dma-header dma-packet :inline :offset-assert 0) + (vif-header uint32 4 :offset-assert 16) + (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 ad-cmd :inline :offset-assert 144) + (alpha-translucent ad-cmd :inline :offset-assert 160) + (ztest-normal ad-cmd :inline :offset-assert 176) + (ztest-opaque ad-cmd :inline :offset-assert 192) + (adcmd-offsets uint8 16 :offset-assert 208) + ;;(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) + ) + :method-count-assert 9 + :size-assert #x1b0 + :flag-assert #x9000001b0 + ) + +;; generic-h +(deftype generic-storage (structure) + ((data uint128 16 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x100 + :flag-assert #x900000100 + ) + +;;;;;;;;;;;;; +;; lights-h +;;;;;;;;;;;;; + +;; lights-h +(deftype vu-lights (structure) + ((direction uint128 3 :offset-assert 0) + (color uint128 3 :offset-assert 48) + (ambient vector :inline :offset-assert 96) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) + +;; lights-h +(deftype light (structure) + ((direction vector :inline :offset-assert 0) + (color rgbaf :inline :offset-assert 16) + (levels vector :inline :offset-assert 32) + (level float :offset 32) + (sort-level float :offset 36) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +;; lights-h +(deftype light-ellipse (structure) + ((matrix matrix :inline :offset-assert 0) + (color rgbaf :inline :offset-assert 64) + (name basic :offset 12) + (decay-start float :offset 28) + (ambient-point-ratio float :offset 44) + (level float :offset 60) + (func-symbol basic :offset 76) + (func basic :offset 76) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + +;; lights-h +(deftype light-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 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; lights-h +(deftype light-volume (basic) + ((light-array basic :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; lights-h +(deftype light-volume-sphere (light-volume) + ((bsphere sphere :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; lights-h +(deftype light-volume-planes (light-volume) + ((planes vertical-planes :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +;; todo +; (deftype light-volume-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 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +;; lights-h +(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 + ) + +;;;;;;;;;;; +;; ocean-h +;;;;;;;;;;; + +;; 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) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + +;; ocean-h +(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 + ) + +;; ocean-h +(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 + ) + +;; ocean-h +(deftype ocean-spheres (structure) + ((spheres uint128 36 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x240 + :flag-assert #x900000240 + ) + +;; ocean-h +(deftype ocean-colors (structure) + ((colors uint32 2548 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x27d0 + :flag-assert #x9000027d0 + ) + +;; ocean-h +(deftype ocean-mid-mask (structure) + ((mask uint8 8 :offset-assert 0) + (dword uint64 :offset 0) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; ocean-h +(deftype ocean-mid-indices (basic) + ((data uint16 36 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x4c + :flag-assert #x90000004c + ) + +;; ocean-h +(deftype ocean-mid-masks (basic) + ((data uint32 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; ocean-h +(deftype ocean-trans-mask (structure) + ((mask uint16 4 :offset-assert 0) + (word uint64 :offset 0) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; ocean-h +(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 + ) + +;; ocean-h +(deftype ocean-trans-indices (basic) + ((data uint32 2304 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x2404 + :flag-assert #x900002404 + ) + +;; ocean-h +(deftype ocean-near-index (structure) + ((data uint16 16 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; ocean-h +(deftype ocean-near-indices (basic) + ((data uint32 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; ocean-h +(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 + ) + +;; ocean-h +(deftype ocean-map (basic) + ((start-corner vector :inline :offset-assert 16) + (far-color vector :inline :offset-assert 32) + (ocean-spheres ocean-spheres :offset-assert 48) + (ocean-colors ocean-colors :offset-assert 52) + (ocean-mid-indices basic :offset-assert 56) + (ocean-trans-indices basic :offset-assert 60) + (ocean-near-indices basic :offset-assert 64) + (ocean-mid-masks basic :offset-assert 68) + ) + :method-count-assert 9 + :size-assert #x48 + :flag-assert #x900000048 + ) + +;; ocean-h +(deftype ocean-trans-strip (structure) + ((verts uint128 10 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #xa0 + :flag-assert #x9000000a0 + ) + +;; ocean-h +(deftype ocean-trans-strip-array (structure) + ((data ocean-trans-strip 4 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x280 + :flag-assert #x900000280 + ) + +;; ocean-h +(deftype ocean-wave-data (structure) + ((data uint8 1024 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x400 + :flag-assert #x900000400 + ) + +; ;; ocean-h +; (deftype ocean-wave-frames (structure) +; ((frame UNKNOWN 64 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x0 +; :flag-assert #x900010000 +; ) + +; ;; ocean-h +; (deftype ocean-work (basic) +; ((deltas vector :inline :offset-assert 16) +; (map-min vector :inline :offset-assert 32) +; (map-max vector :inline :offset-assert 48) +; (interp vector :inline :offset-assert 64) +; (corner-array UNKNOWN 25 :offset-assert 80) +; (corner-count int32 :offset-assert 2080) +; (temp-vecs UNKNOWN 4 :offset-assert 2096) +; (mid-mask-ptrs UNKNOWN 36 :offset-assert 2160) +; (mid-camera-masks UNKNOWN 36 :offset-assert 2304) +; (trans-mask-ptrs UNKNOWN 64 :offset-assert 2592) +; (trans-camera-masks UNKNOWN 16 :offset-assert 2848) +; (trans-temp-masks UNKNOWN 16 :offset-assert 2976) +; (near-mask-indices UNKNOWN 16 :offset-assert 3104) +; (mid-minx uint8 :offset-assert 3136) +; (mid-maxx uint8 :offset-assert 3137) +; (mid-minz uint8 :offset-assert 3138) +; (mid-maxz uint8 :offset-assert 3139) +; (near-minx uint8 :offset-assert 3140) +; (near-maxx uint8 :offset-assert 3141) +; (near-minz uint8 :offset-assert 3142) +; (near-maxz uint8 :offset-assert 3143) +; (temp-minx uint8 :offset-assert 3144) +; (temp-maxx uint8 :offset-assert 3145) +; (temp-minz uint8 :offset-assert 3146) +; (temp-maxz uint8 :offset-assert 3147) +; ) +; :method-count-assert 9 +; :size-assert #xc4c +; :flag-assert #x900000c4c +; ) + +;; ocean-h +(deftype ocean-vu0-work (structure) + ((scales vector :inline :offset-assert 0) + (mask-hi vector4w :inline :offset-assert 16) + (mask-lo vector4w :inline :offset-assert 32) + (lights vu-lights :inline :offset-assert 48) + (wait-to-vu0 uint32 :offset-assert 160) + ) + :method-count-assert 9 + :size-assert #xa4 + :flag-assert #x9000000a4 + ) + +;; ocean-h +(deftype ocean-texture-constants (structure) + ((giftag qword :inline :offset-assert 0) + (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 + ) + +;; ocean-h +(deftype ocean-texture-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) + ) + :method-count-assert 9 + :size-assert #x60 + :flag-assert #x900000060 + ) + +;; ocean-h +(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 + ) + +;; ocean-h +(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) + (env-fan qword :inline :offset-assert 112) + (drw-adgif qword :inline :offset-assert 128) + (drw-texture adgif-shader :inline :offset-assert 144) + (drw-strip-0 qword :inline :offset-assert 224) + (drw-strip-1 qword :inline :offset-assert 240) + (env-adgif qword :inline :offset-assert 256) + (env-texture adgif-shader :inline :offset-assert 272) + (env-strip qword :inline :offset-assert 352) + (env-color vector :inline :offset-assert 368) + (index-table uint128 8 :offset-assert 384) + (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 + ) + +;; ocean-h +(deftype ocean-mid-upload (structure) + ((rot matrix :inline :offset-assert 0) + (matrix matrix :inline :offset-assert 64) + (colors uint128 108 :offset-assert 128) + (masks uint128 2 :offset-assert 1856) + ) + :method-count-assert 9 + :size-assert #x760 + :flag-assert #x900000760 + ) + +;; ocean-h +(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) + ) + :method-count-assert 9 + :size-assert #x230 + :flag-assert #x900000230 + ) + +;; ocean-h +(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) + ) + :method-count-assert 9 + :size-assert #x160 + :flag-assert #x900000160 + ) + +;; ocean-h +(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) + (drw-fan qword :inline :offset-assert 128) + (drw2-fan qword :inline :offset-assert 144) + (env-fan qword :inline :offset-assert 160) + (drw-adgif qword :inline :offset-assert 176) + (drw-texture adgif-shader :inline :offset-assert 192) + (drw-strip qword :inline :offset-assert 272) + (env-adgif qword :inline :offset-assert 288) + (env-texture adgif-shader :inline :offset-assert 304) + (env-strip qword :inline :offset-assert 384) + (env-color vector :inline :offset-assert 400) + (drw2-adgif qword :inline :offset-assert 416) + (drw2-tex0 qword :inline :offset-assert 432) + (drw2-frame qword :inline :offset-assert 448) + (drw2-strip qword :inline :offset-assert 464) + (drw3-adgif qword :inline :offset-assert 480) + (drw3-frame qword :inline :offset-assert 496) + (index-table uint128 4 :offset-assert 512) + ) + :method-count-assert 9 + :size-assert #x240 + :flag-assert #x900000240 + ) + +;; ocean-h +(deftype ocean-near-upload (structure) + ((rot matrix :inline :offset-assert 0) + (matrix matrix :inline :offset-assert 64) + (masks uint128 2 :offset-assert 128) + (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 + ) + +;; ocean-h +(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 + ) + +;; ocean-h +(deftype ocean-near-work (structure) + ((verts-ptr vector :inline :offset-assert 0) + (indices uint128 16 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x110 + :flag-assert #x900000110 + ) + +;;;;;;;;;; +;; sky-h +;;;;;;;;;; + +;; 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 + ) + +;; sky-h +(deftype sky-color-day (structure) + ((hour uint128 24 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x180 + :flag-assert #x900000180 + ) + +;; sky-h +(deftype sky-circle-data (structure) + ((data uint128 17 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x110 + :flag-assert #x900000110 + ) + +;; sky-h +(deftype sky-sun-data (structure) + ((data uint128 4 :offset-assert 0) + (pos vector :inline :offset 0) + (r-sun float :offset 16) + (r-halo float :offset 20) + (r-aurora float :offset 24) + (c-sun-start uint32 :offset 32) + (c-sun-end uint32 :offset 48) + (c-halo-start uint32 :offset 36) + (c-halo-end uint32 :offset 52) + (c-aurora-start uint32 :offset 40) + (c-aurora-end uint32 :offset 56) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +;; sky-h +(deftype sky-moon-data (structure) + ((data uint128 2 :offset-assert 0) + (pos vector :inline :offset 0) + (scale vector :inline :offset 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; sky-h +(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 + ) + +;; sky-h +(deftype sky-upload-data (basic) + ( + ;(data UNKNOWN 27 :offset-assert 16) + (circle sky-circle-data :inline :offset-assert 16) + (sun sky-sun-data 2 :inline :offset-assert 288) + (moon sky-moon-data :inline :offset-assert 416) + (data uint128 27 :offset 16) + ) + :method-count-assert 9 + :size-assert #x1c0 + :flag-assert #x9000001c0 + ) + +; ;; sky-h +; (deftype sky-parms (basic) +; ((orbit UNKNOWN 3 :offset-assert 4) +; (upload-data sky-upload-data :inline :offset-assert 116) +; (sun-lights light-group :inline :offset-assert 560) +; (moon-lights light-group :inline :offset-assert 752) +; (default-lights light-group :inline :offset-assert 944) +; (default-vu-lights vu-lights :inline :offset-assert 1136) +; ) +; :method-count-assert 9 +; :size-assert #x4e0 +; :flag-assert #x9000004e0 +; ) + +;; sky-h +(deftype sky-tng-data (basic) + ((giftag-base qword :inline :offset-assert 16) + (giftag-roof qword :inline :offset-assert 32) + (giftag-ocean qword :inline :offset-assert 48) + (fog vector :inline :offset-assert 64) + (sky uint32 8 :offset-assert 80) + (time float :offset-assert 112) + (off-s-0 uint16 :offset-assert 116) + (off-t-0 uint16 :offset-assert 118) + (off-s-1 uint16 :offset-assert 120) + (off-t-1 uint16 :offset-assert 122) + ) + :method-count-assert 9 + :size-assert #x7c + :flag-assert #x90000007c + ) + +;; sky-h +(deftype sky-work (structure) + ((adgif-tmpl dma-gif-packet :inline :offset-assert 0) + (draw-tmpl dma-gif-packet :inline :offset-assert 32) + (blend-tmpl dma-gif-packet :inline :offset-assert 64) + (sky-data uint128 5 :offset-assert 96) + (cloud-data uint128 5 :offset-assert 176) + ) + :method-count-assert 9 + :size-assert #x100 + :flag-assert #x900000100 + ) + +;; sky-h +(deftype sky-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 + ) + +;; mood-h +(deftype mood-fog (structure) + ((fog-color vector :inline :offset-assert 0) + (fog-dists vector :inline :offset-assert 16) + (fog-start float :offset 16) ;; meters + (fog-end float :offset 20) ;;meters + (fog-max float :offset 24) + (fog-min float :offset 28) + (erase-color vector :inline :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +; ;; mood-h +; (deftype mood-fog-table (structure) +; ((data UNKNOWN 8 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x180 +; :flag-assert #x900000180 +; ) + +;; mood-h +(deftype mood-lights (structure) + ((direction vector :inline :offset-assert 0) + (lgt-color vector :inline :offset-assert 16) + (prt-color vector :inline :offset-assert 32) + (amb-color vector :inline :offset-assert 48) + (shadow vector :inline :offset-assert 64) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + +; ;; mood-h +; (deftype mood-lights-table (structure) +; ((data UNKNOWN 8 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x280 +; :flag-assert #x900000280 +; ) + +;; mood-h +(deftype mood-sun (structure) + ((sun-color vector :inline :offset-assert 0) + (env-color vector :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +; ;; mood-h +; (deftype mood-sun-table (structure) +; ((data UNKNOWN 8 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x100 +; :flag-assert #x900000100 +; ) + +; ;; mood-h +; (deftype mood-context (basic) +; ((mood-fog-table mood-fog-table :offset-assert 4) +; (mood-lights-table mood-lights-table :offset-assert 8) +; (mood-sun-table mood-sun-table :offset-assert 12) +; (fog-interp sky-color-day :offset-assert 16) +; (palette-interp sky-color-day :offset-assert 20) +; (sky-texture-interp sky-color-day :offset-assert 24) +; (current-fog mood-fog :inline :offset-assert 32) +; (current-sun mood-sun :inline :offset-assert 80) +; (current-prt-color vector :inline :offset-assert 112) +; (current-shadow vector :inline :offset-assert 128) +; (current-shadow-color vector :inline :offset-assert 144) +; (light-group UNKNOWN 8 :offset-assert 160) +; (times UNKNOWN 8 :offset-assert 1696) +; (sky-times UNKNOWN 8 :offset-assert 1824) +; (itimes UNKNOWN 4 :offset-assert 1856) +; (state UNKNOWN 16 :offset-assert 1920) +; (num-stars float :offset-assert 1936) +; ) +; :method-count-assert 9 +; :size-assert #x794 +; :flag-assert #x900000794 +; ) + +;; 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 + ) + +; ;; time-of-day-h +; (deftype palette-fade-controls (basic) +; ((control UNKNOWN 8 :offset-assert 16) +; ) +; :method-count-assert 11 +; :size-assert #x110 +; :flag-assert #xb00000110 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +;; time-of-day-h +(deftype time-of-day-proc (process) + ((year int32 :offset-assert 112) + (month int32 :offset-assert 116) + (week int32 :offset-assert 120) + (day int32 :offset-assert 124) + (hour int32 :offset-assert 128) + (minute int32 :offset-assert 132) + (second int32 :offset-assert 136) + (frame int32 :offset-assert 140) + (time-of-day float :offset-assert 144) + (time-ratio float :offset-assert 148) + (star-count int32 :offset-assert 152) + (stars basic :offset-assert 156) + (sun-count int32 :offset-assert 160) + (sun basic :offset-assert 164) + (green-sun-count int32 :offset-assert 168) + (green-sun basic :offset-assert 172) + (moon-count int32 :offset-assert 176) + (moon basic :offset-assert 180) + ) + :heap-base #x50 + :method-count-assert 14 + :size-assert #xb8 + :flag-assert #xe005000b8 + ;; inherited inpspect of process + ) + +;; time-of-day-h +(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) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) + +; ;; time-of-day-h +; (deftype time-of-day-context (basic) +; ((active-count uint32 :offset-assert 4) +; (interp float :offset-assert 8) +; (current-interp float :offset-assert 12) +; (moods UNKNOWN 2 :offset-assert 16) +; (current-fog mood-fog :inline :offset-assert 32) +; (current-sun mood-sun :inline :offset-assert 80) +; (current-prt-color vector :inline :offset-assert 112) +; (current-shadow vector :inline :offset-assert 128) +; (current-shadow-color vector :inline :offset-assert 144) +; (light-group UNKNOWN 9 :offset-assert 160) +; (title-light-group light-group :inline :offset-assert 1888) +; (time float :offset-assert 2080) +; (target-interp float :offset-assert 2084) +; (erase-color uint32 :offset-assert 2088) +; (num-stars float :offset-assert 2092) +; (light-masks-0 UNKNOWN 2 :offset-assert 2096) +; (light-masks-1 UNKNOWN 2 :offset-assert 2098) +; (light-interp UNKNOWN 2 :offset-assert 2100) +; (sky basic :offset-assert 2108) +; (sun-fade float :offset-assert 2112) +; (title-updated basic :offset-assert 2116) +; ) +; :method-count-assert 9 +; :size-assert #x848 +; :flag-assert #x900000848 +; ) + +; ;; time-of-day-h +; (deftype time-of-day-dma (structure) +; ((outa UNKNOWN 256 :offset-assert 0) +; (outb UNKNOWN 256 :offset-assert 1024) +; (banka UNKNOWN 256 :offset-assert 2048) +; (bankb UNKNOWN 256 :offset-assert 3072) +; ) +; :method-count-assert 9 +; :size-assert #x1000 +; :flag-assert #x900001000 +; ) + +;; art-h +(deftype joint-anim (basic) + ((name basic :offset-assert 4) + (number int16 :offset-assert 8) + (length int16 :offset-assert 10) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +; ;; art-h +; (deftype joint-anim-drawable (joint-anim) +; ((name basic :offset-assert 4) +; (number int16 :offset-assert 8) +; (length int16 :offset-assert 10) +; (data UNKNOWN :dynamic :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +;; art-h +(deftype joint-anim-compressed (joint-anim) + () + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +; ;; art-h +; (deftype joint-anim-frame (structure) +; ((matrices UNKNOWN 2 :offset-assert 0) +; (data UNKNOWN :dynamic :offset-assert 128) +; ) +; :method-count-assert 9 +; :size-assert #x80 +; :flag-assert #x900000080 +; ) + +; ;; art-h +; (deftype joint-anim-compressed-hdr (structure) +; ((control-bits UNKNOWN 14 :offset-assert 0) +; (num-joints uint32 :offset-assert 56) +; (matrix-bits uint32 :offset-assert 60) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; art-h +; (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 UNKNOWN 133 :offset-assert 80) +; ) +; :method-count-assert 9 +; :size-assert #x8a0 +; :flag-assert #x9000008a0 +; ) + +; ;; art-h +; (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 UNKNOWN 133 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x860 +; :flag-assert #x900000860 +; ) + +; ;; art-h +; (deftype joint-anim-compressed-control (structure) +; ((num-frames uint32 :offset-assert 0) +; (fixed-qwc uint32 :offset-assert 4) +; (frame-qwc uint32 :offset-assert 8) +; (fixed joint-anim-compressed-fixed :offset-assert 12) +; (data UNKNOWN 1 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +;; art-h +(deftype art (basic) + ((name basic :offset 8) + (length int32 :offset-assert 12) + (extra basic :offset-assert 16) + ) + :method-count-assert 13 + :size-assert #x14 + :flag-assert #xd00000014 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) + +;; art-h +(deftype art-element (art) + ((pad uint8 12)) + :method-count-assert 13 + :size-assert #x20 + :flag-assert #xd00000020 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) + +; ;; art-h +; (deftype skeleton-group (basic) +; ((art-group-name basic :offset-assert 4) +; (jgeo int32 :offset-assert 8) +; (janim int32 :offset-assert 12) +; (bounds vector :inline :offset-assert 16) +; (radius meters :offset-assert 28) +; (mgeo UNKNOWN 4 :offset-assert 32) +; (max-lod int32 :offset-assert 40) +; (lod-dist UNKNOWN 4 :offset-assert 44) +; (longest-edge meters :offset-assert 60) +; (texture-level int8 :offset-assert 64) +; (version int8 :offset-assert 65) +; (shadow int8 :offset-assert 66) +; (sort int8 :offset-assert 67) +; ) +; :method-count-assert 9 +; :size-assert #x48 +; :flag-assert #x900000048 +; ) + +;; art-h +(deftype lod-group (structure) + ((geo basic :offset-assert 0) + (dist float :offset-assert 4) ;; meters + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +; ;; art-h +; (deftype lod-set (structure) +; ((lod UNKNOWN 4 :offset-assert 0) +; (max-lod int8 :offset-assert 32) +; ) +; :method-count-assert 10 +; :size-assert #x21 +; :flag-assert #xa00000021 +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; art-h +; (deftype draw-control (basic) +; ((status uint8 :offset-assert 4) +; (matrix-type uint8 :offset-assert 5) +; (data-format uint8 :offset-assert 6) +; (global-effect uint8 :offset-assert 7) +; (art-group basic :offset-assert 8) +; (jgeo basic :offset-assert 12) +; (mgeo basic :offset-assert 16) +; (dma-add-func basic :offset-assert 20) +; (skeleton basic :offset-assert 24) +; (lod-set lod-set :inline :offset-assert 28) +; (lod UNKNOWN 4 :offset-assert 28) +; (max-lod int8 :offset-assert 60) +; (force-lod int8 :offset-assert 61) +; (cur-lod int8 :offset-assert 62) +; (desired-lod int8 :offset-assert 63) +; (ripple basic :offset-assert 64) +; (longest-edge meters :offset-assert 68) +; (longest-edge? uint32 :offset-assert 68) +; (light-index uint8 :offset-assert 72) +; (dummy UNKNOWN 2 :offset-assert 73) +; (death-draw-overlap uint8 :offset-assert 75) +; (death-timer uint8 :offset-assert 76) +; (death-timer-org uint8 :offset-assert 77) +; (death-vertex-skip uint16 :offset-assert 78) +; (death-effect uint32 :offset-assert 80) +; (sink-group basic :offset-assert 84) +; (process basic :offset-assert 88) +; (shadow basic :offset-assert 92) +; (shadow-ctrl basic :offset-assert 96) +; (origin vector :inline :offset-assert 112) +; (bounds vector :inline :offset-assert 128) +; (radius meters :offset-assert 140) +; (color-mult rgbaf :inline :offset-assert 144) +; (color-emissive rgbaf :inline :offset-assert 160) +; (secondary-interp float :offset-assert 176) +; (current-secondary-interp float :offset-assert 180) +; (shadow-mask uint8 :offset-assert 184) +; (level-index uint8 :offset-assert 185) +; (origin-joint-index uint8 :offset-assert 186) +; (shadow-joint-index uint8 :offset-assert 187) +; ) +; :method-count-assert 12 +; :size-assert #xbc +; :flag-assert #xc000000bc +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; generic-vu1-h +; (deftype pris-mtx (structure) +; ((data UNKNOWN 32 :offset-assert 0) +; (vector UNKNOWN 8 :offset-assert 0) +; (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 +; ) + +; ;; generic-vu1-h +; (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 +; ) + +;; generic-vu1-h +(deftype generic-constants (structure) + ((fog vector :inline :offset-assert 0) + (adgif qword :inline :offset-assert 16) + (giftag qword :inline :offset-assert 32) + (hvdf-offset vector :inline :offset-assert 48) + (hmge-scale vector :inline :offset-assert 64) + (invh-scale vector :inline :offset-assert 80) + (guard vector :inline :offset-assert 96) + (adnop qword :inline :offset-assert 112) + (flush qword :inline :offset-assert 128) + (stores qword :inline :offset-assert 144) + ) + :method-count-assert 9 + :size-assert #xa0 + :flag-assert #x9000000a0 + ) + + +;; 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) + (data2 uint8 :dynamic :offset-assert 32) ;; renamed from data. suspect inline-array has some magic. + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; merc-h +(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) + ) + :method-count-assert 9 + :size-assert #x17 + :flag-assert #x900000017 + ) + +;; merc-h +(deftype merc-fragment (structure) + ((header merc-byte-header :inline :offset-assert 0) + (rest uint8 1 :offset-assert 23) + ) + :method-count-assert 10 + :size-assert #x18 + :flag-assert #xa00000018 + (:methods + (dummy-9 () none 9) + ) + ) + +;; merc-h +(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 + ) + +;; merc-h +(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 + ) + +;; merc-h +(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 + ) + +;; merc-h +(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 uint8 :dynamic :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +;; merc-h +(deftype merc-blend-data (structure) ;; was unknown! + ((int8-data int8 :dynamic :offset-assert 0) + ) + ) + +;; merc-h +(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) + ) + :method-count-assert 9 + :size-assert #x2 + :flag-assert #x900000002 + ) + +;; merc-h +(deftype mei-envmap-tint (structure) + ((fade0 float :offset-assert 0) + (fade1 float :offset-assert 4) + (tint uint32 :offset-assert 8) + (dummy int32 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; merc-h +(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) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; merc-h +(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 + ) + +;; merc-h +(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) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +; ;; merc-h +(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) + (dummy0 uint8 :offset-assert 16) + (effect-bits uint8 :offset-assert 17) + (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) + (dummy1 uint8 :offset-assert 26) + (envmap-usage uint8 :offset-assert 27) + (extra-info merc-extra-info :offset-assert 28) + ) + :method-count-assert 10 + :size-assert #x20 + :flag-assert #xa00000020 + (:methods + (dummy-9 () none 9) + ) + ) + +;; merc-h +(deftype merc-eye-ctrl (structure) + ((eye-slot int8 :offset-assert 0) + (shader-offset int8 :offset-assert 1) + (shader-count int8 :offset-assert 2) + ;(shader UNKNOWN 3 :offset-assert 16) + (iris-shader adgif-shader :inline :offset-assert 16) + (pupil-shader adgif-shader :inline :offset-assert 96) + (lid-shader adgif-shader :inline :offset-assert 176) + ) + :method-count-assert 9 + :size-assert #x100 + :flag-assert #x900000100 + ) + +;; merc-h +(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 4) + (pupil-scale int8 :offset-assert 5) + (lid-scale int8 :offset-assert 6) + (dword uint64 :offset 0) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; merc-h +(deftype merc-eye-anim-block (structure) + ((max-frame int16 :offset-assert 0) + (data uint8 :dynamic :offset 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; merc-h +(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) + (masks uint32 3 :offset-assert 68) + (dummy-bytes uint8 48 :offset 32) + (envmap-tint uint32 :offset 32) + (query basic :offset 36) + (needs-clip uint8 :offset 40) + (use-isometric uint8 :offset 41) + (use-attached-shader uint8 :offset 42) + (display-triangles uint8 :offset 43) + (death-vertex-skip uint16 :offset 44) + (death-start-vertex uint16 :offset 46) + (death-effect uint32 :offset 48) + (use-translucent uint8 :offset 52) + (display-this-fragment uint8 :offset 53) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ;; field xyz-scale is a float printed as hex? + ) + +;; merc-h +(deftype merc-ctrl (art-element) + ((num-joints int32 :offset 20) + (header merc-ctrl-header :inline :offset-assert 32) + (effect uint8 :dynamic :offset-assert 112) + ) + :method-count-assert 13 + :size-assert #x70 + :flag-assert #xd00000070 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) + +;; merc-h +(deftype merc-vu1-low-mem (structure) + ((tri-strip-gif qword :inline :offset-assert 0) + (ad-gif qword :inline :offset-assert 16) + (hvdf-offset vector :inline :offset-assert 32) + (perspective uint128 4 :offset-assert 48) + (fog vector :inline :offset-assert 112) + ) + :method-count-assert 9 + :size-assert #x80 + :flag-assert #x900000080 + ) + +;; merc-h +(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) + ) + :pack-me + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) + +;; merc-h +(deftype ripple-wave-set (basic) + ((count int32 :offset-assert 4) + (converted basic :offset-assert 8) + (frame-save uint32 :offset-assert 12) + (normal-scale float :offset-assert 16) + (wave ripple-wave 4 :inline :offset-assert 20) + ) + :method-count-assert 9 + :size-assert #x84 + :flag-assert #x900000084 + ) + +;; merc-h +(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 basic :offset-assert 28) + (send-query basic :offset-assert 32) + (query basic :offset-assert 36) + ) + :method-count-assert 9 + :size-assert #x28 + :flag-assert #x900000028 + ) + +;; generic-merc-h +(deftype merc-matrix (structure) + ((quad uint128 8 :offset-assert 0) + (vector vector 8 :inline :offset 0) + (tag uint64 :offset 0) + ) + :method-count-assert 9 + :size-assert #x80 + :flag-assert #x900000080 + ) + +;; generic-merc-h +(deftype generic-merc-tag (dma-packet) + ((next-ptr uint32 :offset 12) + (size uint32 :offset 8) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; generic-merc-h +(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 208) + ) + :method-count-assert 9 + :size-assert #xf0 + :flag-assert #x9000000f0 + ) + +;; generic-merc-h +(deftype generic-merc-ctrl-with-sfx (generic-merc-ctrl) + ((sfx-data uint128 11 :offset-assert 240) + ) + :method-count-assert 9 + :size-assert #x1a0 + :flag-assert #x9000001a0 + ) + +;; generic-merc-h +; (deftype generic-merc-input (structure) +; ((geo-tag generic-merc-tag :inline :offset-assert 0) +; (geo-block UNKNOWN 1296 :offset-assert 16) +; (byte-header merc-byte-header :inline :offset-assert 16) +; (matrix UNKNOWN 9 :offset-assert 1312) +; (control generic-merc-ctrl-with-sfx :inline :offset-assert 2464) +; (end-tag generic-merc-tag :inline :offset-assert 2880) +; (shader adgif-shader :inline :offset-assert 2896) +; ) +; :method-count-assert 9 +; :size-assert #xba0 +; :flag-assert #x900000ba0 +; ) + +; ;; generic-merc-h +; (deftype generic-merc-output (structure) +; ((info gsf-info :inline :offset-assert 0) +; (header gsf-header :inline :offset-assert 16) +; (index-kick-table UNKNOWN 80 :offset-assert 32) +; (index-table UNKNOWN 160 :offset-assert 32) +; (inverse-table UNKNOWN 256 :offset-assert 192) +; (vertex-table UNKNOWN 72 :offset-assert 448) +; ) +; :method-count-assert 9 +; :size-assert #xac0 +; :flag-assert #x900000ac0 +; ) + +; ;; generic-merc-h +; (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 UNKNOWN 544 :offset-assert 5504) +; (inv-table-7 UNKNOWN 544 :offset-assert 6048) +; (inv-safety UNKNOWN 16 :offset-assert 6592) +; (effect-data UNKNOWN 1584 :offset-assert 6608) +; ) +; :method-count-assert 9 +; :size-assert #x2000 +; :flag-assert #x900002000 +; ) + +; ;; generic-merc-h +; (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) +; (mercneric-convert basic :offset-assert 320) +; (generic-prepare-dma-single basic :offset-assert 324) +; (generic-prepare-dma-double basic :offset-assert 328) +; (generic-light-proc basic :offset-assert 332) +; (generic-envmap-proc basic :offset-assert 336) +; (high-speed-reject basic :offset-assert 340) +; (hsr-xmult vector :inline :offset-assert 352) +; (hsr-ymult vector :inline :offset-assert 368) +; ) +; :method-count-assert 9 +; :size-assert #x180 +; :flag-assert #x900000180 +; ) + +; ;; generic-merc-h +; (deftype generic-merc-work (structure) +; ((input-a generic-merc-input :inline :offset-assert 0) +; (input-b generic-merc-input :inline :offset-assert 2976) +; (ctrl generic-merc-ctrl-with-sfx :inline :offset-assert 5952) +; (shadow gm-shadow :inline :offset-assert 6368) +; (stack UNKNOWN 16 :offset-assert 6752) +; ) +; :method-count-assert 9 +; :size-assert #x1b60 +; :flag-assert #x900001b60 +; ) + +; ;; generic-tie-h +; (deftype generic-tie-instance (structure) +; ((matrix-tag dma-packet :inline :offset-assert 0) +; (matrix-data UNKNOWN 6 :offset-assert 16) +; (index-tag dma-packet :inline :offset-assert 112) +; (indices UNKNOWN 224 :offset-assert 128) +; (end-tag dma-packet :inline :offset-assert 352) +; ) +; :method-count-assert 9 +; :size-assert #x170 +; :flag-assert #x900000170 +; ) + +; ;; generic-tie-h +; (deftype generic-tie-input (structure) +; ((palette-tag dma-packet :inline :offset-assert 0) +; (palette UNKNOWN 128 :offset-assert 16) +; (model-tag dma-packet :inline :offset-assert 528) +; (model UNKNOWN 146 :offset-assert 544) +; (matrix-tag dma-packet :inline :offset-assert 2880) +; (matrix-data UNKNOWN 6 :offset-assert 2896) +; (index-tag dma-packet :inline :offset-assert 2992) +; (indices UNKNOWN 224 :offset-assert 3008) +; (end-tag dma-packet :inline :offset-assert 3232) +; ) +; :method-count-assert 9 +; :size-assert #xcb0 +; :flag-assert #x900000cb0 +; ) + +; ;; generic-tie-h +; (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 +; ) + +; ;; generic-tie-h +; (deftype generic-tie-base-point (structure) +; ((data UNKNOWN 8 :offset-assert 0) +; (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 +; ) + +; ;; generic-tie-h +; (deftype generic-tie-bps (structure) +; ((bp UNKNOWN 4 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; generic-tie-h +; (deftype generic-tie-interp-point (structure) +; ((data UNKNOWN 12 :offset-assert 0) +; (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 +; ) + +; ;; generic-tie-h +; (deftype generic-tie-ips (structure) +; ((ip UNKNOWN 2 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; generic-tie-h +; (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 +; ) + +; ;; generic-tie-h +; (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 +; ) + +; ;; generic-tie-h +; (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 +; ) + +; ;; generic-tie-h +; (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 +; ) + +; ;; generic-tie-h +; (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 +; ) + +; ;; generic-tie-h +; (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 +; ) + +; ;; generic-tie-h +; (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 +; ) + +; ;; generic-tie-h +; (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 UNKNOWN 128 :offset-assert 6992) +; ) +; :method-count-assert 9 +; :size-assert #x1d50 +; :flag-assert #x900001d50 +; ) + +; ;; generic-work-h +; (deftype generic-input-buffer (structure) +; ((data UNKNOWN 472 :offset-assert 0) +; (merc generic-merc-work :inline :offset-assert 0) +; (tie generic-tie-work :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x1d80 +; :flag-assert #x900001d80 +; ) + +; ;; generic-work-h +; (deftype generic-debug (structure) +; ((locks UNKNOWN 4 :offset-assert 0) +; (timer UNKNOWN 32 :offset-assert 16) +; (count UNKNOWN 32 :offset-assert 144) +; (vps UNKNOWN 32 :offset-assert 272) +; (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 +; ) + +; ;; generic-work-h +; (deftype generic-vu1-header (structure) +; ((matrix matrix :inline :offset-assert 0) +; (strgif generic-gif-tag :inline :offset-assert 64) +; (adcmds UNKNOWN 2 :offset-assert 80) +; (adnop1 ad-cmd :inline :offset-assert 80) +; (adnop2 ad-cmd :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 +; ) + +; ;; generic-work-h +; (deftype generic-vu1-texbuf (structure) +; ((header generic-vu1-header :inline :offset-assert 0) +; (shader UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 9 +; :size-assert #x70 +; :flag-assert #x900000070 +; ) + +; ;; generic-work-h +; (deftype generic-texbuf (structure) +; ((tag dma-packet :inline :offset-assert 0) +; (header generic-vu1-header :inline :offset-assert 16) +; (shader UNKNOWN :dynamic :offset-assert 128) +; ) +; :method-count-assert 9 +; :size-assert #x80 +; :flag-assert #x900000080 +; ) + +; ;; generic-work-h +; (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 +; ) + +; ;; generic-work-h +; (deftype generic-effect-buffer (structure) +; ((outbuf-0 UNKNOWN 3552 :offset-assert 0) +; (work generic-effect-work :inline :offset-assert 3552) +; (outbuf-1 UNKNOWN 3552 :offset-assert 4608) +; ) +; :method-count-assert 9 +; :size-assert #x1fe0 +; :flag-assert #x900001fe0 +; ) + +; ;; generic-work-h +; (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 8176) +; ) +; :method-count-assert 9 +; :size-assert #x3fd0 +; :flag-assert #x900003fd0 +; ) + +; ;; shadow-cpu-h +(deftype shadow-settings (structure) + ((center vector :inline :offset-assert 0) + (flags int32 :offset 12) + (shadow-dir vector :inline :offset-assert 16) + (dist-to-locus float :offset 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) + (dummy-3 int32 :offset-assert 76) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + +; ;; shadow-cpu-h +(deftype shadow-control (basic) + ((settings shadow-settings :inline :offset-assert 16) + ) + :method-count-assert 16 + :size-assert #x60 + :flag-assert #x1000000060 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + ) + ) + +;; shadow-cpu-h +(deftype shadow-data (structure) + ((texoffset vector :inline :offset-assert 0) + (texscale vector :inline :offset-assert 16) + (clrs uint128 2 :offset-assert 32) + (dma-unpack-template dma-packet :inline :offset-assert 64) + (dma-cnt uint64 :offset-assert 80) + (vif-nop uint32 :offset-assert 88) + (vif-unpack-v4-8 uint32 :offset-assert 92) + (pdc basic :offset-assert 96) + (dist float :offset-assert 100) + (oddeven uint8 :offset-assert 104) + (waits uint32 :offset-assert 108) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) + +;; shadow-cpu-h +(deftype shadow-work (structure) + ((shadow-data shadow-data :inline :offset-assert 0) + (inbuf uint128 600 :offset-assert 112) + ) + :method-count-assert 9 + :size-assert #x25f0 + :flag-assert #x9000025f0 + ) + +;; shadow-cpu-h +(deftype shadow-run (structure) + ((first uint32 :offset-assert 0) + (next uint32 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; shadow-cpu-h +; (deftype shadow-queue (structure) +; ((num-runs uint32 :offset-assert 0) +; (cur-run uint32 :offset-assert 4) +; (run UNKNOWN 15 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xf8 +; :flag-assert #x9000000f8 +; ) + +;; shadow-cpu-h +(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 + ) + +;; shadow-cpu-h +(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 + ) + +;; shadow-cpu-h +; (deftype shadow-edge (structure) +; ((ind-0 uint16 :offset-assert 0) +; (ind-1 uint16 :offset-assert 2) +; (tri-0 uint16 :offset-assert 4) +; (tri-1 uint16 :offset-assert 6) +; ) +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ) + +;; shadow-cpu-h +(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 + ) + +;; shadow-cpu-h +(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 + ) + +;; shadow-cpu-h +(deftype shadow-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 + ) + +;; shadow-cpu-h +(deftype shadow-geo (art-element) + ((total-size uint32 :offset-assert 32) + (header shadow-header :inline :offset 32) + (rest uint64 :dynamic :offset-assert 80) + ) + :method-count-assert 13 + :size-assert #x50 + :flag-assert #xd00000050 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) + +;; memcard-h +(deftype mc-file-info (structure) + ((present int32 :offset-assert 0) + (blind-data float 16 :offset-assert 4) + (blind-data-int8 int8 64 :offset 4) + (level-index int32 :offset 4) + (fuel-cell-count float :offset 8) + (money-count float :offset 12) + (buzzer-count float :offset 16) + (completion-percentage float :offset 20) + (minute uint8 :offset 24) + (hour uint8 :offset 25) + (week uint8 :offset 26) + (day uint8 :offset 27) + (month uint8 :offset 28) + (year uint8 :offset 29) + ) + :pack-me + :method-count-assert 9 + :size-assert #x44 + :flag-assert #x900000044 + ) + +;; memcard-h +(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 :inline :offset-assert 28) + ) + :method-count-assert 9 + :size-assert #x12c + :flag-assert #x90000012c + ) + +;; 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 + ) + +;; game-info-h +(deftype level-buffer-state (structure) + ((name basic :offset-assert 0) + (display? basic :offset-assert 4) + (force-vis? basic :offset-assert 8) + (force-inside? basic :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +; ;; game-info-h +; (deftype load-state (basic) +; ((want UNKNOWN 2 :offset-assert 4) +; (vis-nick basic :offset-assert 36) +; (command-list basic :offset-assert 40) +; (object-name UNKNOWN 256 :offset-assert 44) +; (object-status UNKNOWN 256 :offset-assert 1068) +; ) +; :method-count-assert 21 +; :size-assert #x82c +; :flag-assert #x150000082c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +;; game-info-h +(deftype continue-point (basic) + ((name basic :offset-assert 4) + (level basic :offset-assert 8) + (flags uint32 :offset-assert 12) + (trans vector :inline :offset-assert 16) + (quat vector :inline :offset-assert 32) + (camera-trans vector :inline :offset-assert 48) + (camera-rot float 9 :offset-assert 64) + (load-commands basic :offset-assert 100) + (vis-nick basic :offset-assert 104) + (lev0 basic :offset-assert 108) + (disp0 basic :offset-assert 112) + (lev1 basic :offset-assert 116) + (disp1 basic :offset-assert 120) + ) + :method-count-assert 10 + :size-assert #x7c + :flag-assert #xa0000007c + (:methods + (dummy-9 () none 9) + ) + ) + +;; game-info-h +(deftype game-info (basic) + ((mode basic :offset-assert 4) + (save-name basic :offset-assert 8) + (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) + (deaths-per-level uint8 32 :offset-assert 60) + (buzzer-total float :offset-assert 92) + (fuel float :offset-assert 96) + (perm-list basic :offset-assert 100) + (task-perm-list basic :offset-assert 104) + (current-continue basic :offset-assert 108) + (text-ids-seen basic :offset-assert 112) + (level-opened uint8 32 :offset-assert 116) + (hint-control basic :offset-assert 148) + (task-hint-control basic :offset-assert 152) + (total-deaths int32 :offset-assert 156) + (continue-deaths int32 :offset-assert 160) + (fuel-cell-deaths int32 :offset-assert 164) + (game-start-time uint64 :offset-assert 168) + (continue-time uint64 :offset-assert 176) + (death-time uint64 :offset-assert 184) + (hit-time uint64 :offset-assert 192) + (fuel-cell-pickup-time uint64 :offset-assert 200) + (fuel-cell-time basic :offset-assert 208) + (enter-level-time basic :offset-assert 212) + (in-level-time basic :offset-assert 216) + (blackout-time uint64 :offset-assert 224) + (letterbox-time uint64 :offset-assert 232) + (hint-play-time uint64 :offset-assert 240) + (display-text-time uint64 :offset-assert 248) + (display-text-handle uint64 :offset-assert 256) + (death-movie-tick int32 :offset-assert 264) + (want-auto-save basic :offset-assert 268) + (auto-save-proc uint64 :offset-assert 272) + (auto-save-status uint32 :offset-assert 280) + (auto-save-card int32 :offset-assert 284) + (auto-save-which int32 :offset-assert 288) + (pov-camera-handle uint64 :offset-assert 296) + (other-camera-handle uint64 :offset-assert 304) + (death-pos basic :offset-assert 312) + (dummy basic :offset-assert 316) + (auto-save-count int32 :offset-assert 320) + ) + :method-count-assert 29 + :size-assert #x144 + :flag-assert #x1d00000144 + ;; field dummy is a basic loaded with a signed load + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + (dummy-27 () none 27) + (dummy-28 () none 28) + ) + ) + +;; wind-h +(deftype wind-vector (structure) + ((wind-pos vector2w :inline :offset-assert 0) + (wind-vel vector2w :inline :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +; ;; wind-h +; (deftype wind-work (basic) +; ((wind-array UNKNOWN 64 :offset-assert 16) +; (wind-normal vector :inline :offset-assert 1040) +; (wind-temp vector :inline :offset-assert 1056) +; (wind-force UNKNOWN 64 :offset-assert 1072) +; (wind-time uint32 :offset-assert 1328) +; ) +; :method-count-assert 9 +; :size-assert #x534 +; :flag-assert #x900000534 +; ) + +; ;; prototype-h +; (deftype prototype-bucket (basic) +; ((name basic :offset-assert 4) +; (flags uint32 :offset-assert 8) +; (in-level uint16 :offset-assert 12) +; (utextures uint16 :offset-assert 14) +; (geometry UNKNOWN 4 :offset-assert 16) +; (dists vector :inline :offset-assert 32) +; (rdists vector :inline :offset-assert 48) +; (next UNKNOWN 4 :offset-assert 64) +; (count UNKNOWN 4 :offset-assert 80) +; (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) +; (next-clear uint128 :offset-assert 64) +; (count-clear uint64 :offset-assert 80) +; ) +; :method-count-assert 9 +; :size-assert #x58 +; :flag-assert #x900000058 +; ) + +; ;; prototype-h +; (deftype prototype-bucket-shrub (prototype-bucket) +; ((name basic :offset-assert 4) +; (flags uint32 :offset-assert 8) +; (in-level uint16 :offset-assert 12) +; (utextures uint16 :offset-assert 14) +; (geometry UNKNOWN 4 :offset-assert 16) +; (dists vector :inline :offset-assert 32) +; (rdists vector :inline :offset-assert 48) +; (next UNKNOWN 4 :offset-assert 64) +; (count UNKNOWN 4 :offset-assert 80) +; (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) +; (next-clear uint128 :offset-assert 64) +; (count-clear uint64 :offset-assert 80) +; (mod-count UNKNOWN 4 :offset-assert 88) +; (last UNKNOWN 4 :offset-assert 96) +; (last-clear uint128 :offset-assert 96) +; ) +; :method-count-assert 9 +; :size-assert #x70 +; :flag-assert #x900000070 +; ) + +; ;; prototype-h +; (deftype prototype-inline-array-shrub (drawable) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (length int16 :offset-assert 6) +; (data UNKNOWN 1 :offset-assert 36) +; ) +; :method-count-assert 18 +; :size-assert #x94 +; :flag-assert #x1200000094 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; prototype-h +; (deftype prototype-array-shrub-info (basic) +; ((prototype-inline-array-shrub basic :offset-assert 4) +; (wind-vectors uint32 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; prototype-h +; (deftype prototype-bucket-tie (prototype-bucket) +; ((name basic :offset-assert 4) +; (flags uint32 :offset-assert 8) +; (in-level uint16 :offset-assert 12) +; (utextures uint16 :offset-assert 14) +; (geometry UNKNOWN 4 :offset-assert 16) +; (dists vector :inline :offset-assert 32) +; (rdists vector :inline :offset-assert 48) +; (next UNKNOWN 4 :offset-assert 64) +; (count UNKNOWN 4 :offset-assert 80) +; (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) +; (next-clear uint128 :offset-assert 64) +; (count-clear uint64 :offset-assert 80) +; (generic-count UNKNOWN 4 :offset-assert 88) +; (generic-next UNKNOWN 4 :offset-assert 96) +; (frag-count UNKNOWN 4 :offset-assert 112) +; (index-start UNKNOWN 4 :offset-assert 116) +; (base-qw UNKNOWN 4 :offset-assert 120) +; (envmap-rfade float :offset-assert 128) +; (envmap-fade-far float :offset-assert 132) +; (envmap-shader adgif-shader :offset-assert 136) +; (collide-frag basic :offset-assert 140) +; (tie-colors basic :offset-assert 144) +; (data UNKNOWN :dynamic :offset-assert 148) +; (color-index-qwc UNKNOWN :dynamic :offset-assert 148) +; (generic-next-clear uint128 :offset-assert 96) +; (generic-count-clear uint128 :offset-assert 80) +; ) +; :method-count-assert 9 +; :size-assert #x94 +; :flag-assert #x900000094 +; ) + +; ;; prototype-h +; (deftype prototype-array-tie (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 +; (dummy-9 () none 9) +; ) +; ) + +; ;; prototype-h +; (deftype proxy-prototype-array-tie (basic) +; ((prototype-array-tie basic :offset-assert 4) +; (wind-vectors uint32 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; prototype-h +; (deftype instance (drawable) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (bucket-index uint16 :offset-assert 6) +; (origin matrix4h :inline :offset-assert 32) +; (wind-index uint16 :offset-assert 62) +; ) +; :method-count-assert 18 +; :size-assert #x40 +; :flag-assert #x1200000040 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; joint-h +; (deftype joint-control-channel (structure) +; ((parent basic :offset-assert 0) +; (command basic :offset-assert 4) +; (frame-interp float :offset-assert 8) +; (frame-group basic :offset-assert 12) +; (frame-num float :offset-assert 16) +; (num-func basic :offset-assert 20) +; (param UNKNOWN 2 :offset-assert 24) +; (group-sub-index int16 :offset-assert 32) +; (group-size int16 :offset-assert 34) +; (dist meters :offset-assert 36) +; (eval-time uint32 :offset-assert 40) +; (inspector-amount float :offset-assert 44) +; ) +; :method-count-assert 10 +; :size-assert #x30 +; :flag-assert #xa00000030 +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; joint-h +; (deftype joint-control (basic) +; ((status uint16 :offset-assert 4) +; (allocated-length int16 :offset-assert 6) +; (root-channel uint32 :offset-assert 16) +; (blend-index int32 :offset-assert 20) +; (active-channels int32 :offset-assert 24) +; (generate-frame-function basic :offset-assert 28) +; (prebind-function basic :offset-assert 32) +; (postbind-function basic :offset-assert 36) +; (effect basic :offset-assert 40) +; (channel UNKNOWN :dynamic :offset-assert 48) +; (frame-group0 basic :offset-assert 60) +; (frame-num0 float :offset-assert 64) +; (frame-interp0 float :offset-assert 56) +; (frame-group1 basic :offset-assert 108) +; (frame-num1 float :offset-assert 112) +; (frame-interp1 float :offset-assert 104) +; (frame-group2 basic :offset-assert 156) +; (frame-num2 float :offset-assert 160) +; (frame-interp2 float :offset-assert 152) +; ) +; :method-count-assert 11 +; :size-assert #xc0 +; :flag-assert #xb000000c0 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; joint-h +; (deftype matrix-stack (structure) +; ((top matrix :offset-assert 0) +; (data UNKNOWN 24 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x610 +; :flag-assert #x900000610 +; ) + +; ;; joint-h +; (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 +; ) + +; ;; joint-h +; (deftype joint-work (structure) +; ((temp-mtx matrix :inline :offset-assert 0) +; (joint-stack matrix-stack :inline :offset-assert 64) +; (fix-jmp-table UNKNOWN 16 :offset-assert 1616) +; (frm-jmp-table UNKNOWN 16 :offset-assert 1680) +; (pair-jmp-table UNKNOWN 16 :offset-assert 1744) +; (uploads UNKNOWN 24 :offset-assert 1808) +; (num-uploads int32 :offset-assert 2384) +; (mtx-acc UNKNOWN 2 :offset-assert 2400) +; (tq-acc UNKNOWN 100 :offset-assert 2528) +; (jacp-hdr joint-anim-compressed-hdr :inline :offset-assert 7328) +; (fixed-data joint-anim-compressed-fixed :inline :offset-assert 7392) +; (frame-data UNKNOWN 2 :offset-assert 9600) +; (flatten-array UNKNOWN 576 :offset-assert 2400) +; (flattened UNKNOWN 24 :offset-assert 2400) +; ) +; :method-count-assert 9 +; :size-assert #x3640 +; :flag-assert #x900003640 +; ) + +; ;; bones-h +; (deftype bone-buffer (structure) +; ((joint UNKNOWN 16 :offset-assert 0) +; (bone UNKNOWN 16 :offset-assert 1024) +; (output UNKNOWN 16 :offset-assert 2560) +; ) +; :method-count-assert 9 +; :size-assert #x1200 +; :flag-assert #x900001200 +; ) + +; ;; bones-h +; (deftype bone-layout (structure) +; ((data UNKNOWN 8 :offset-assert 0) +; (joint UNKNOWN 2 :offset-assert 0) +; (bone UNKNOWN 2 :offset-assert 8) +; (output UNKNOWN 2 :offset-assert 16) +; (cache UNKNOWN 2 :offset-assert 24) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; bones-h +; (deftype bone-regs (structure) +; ((joint-ptr uint32 :offset-assert 0) +; (bone-ptr uint32 :offset-assert 4) +; (num-bones uint32 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; bones-h +; (deftype bone-work (structure) +; ((layout bone-layout :inline :offset-assert 0) +; (bounds sphere :inline :offset-assert 32) +; (lights vu-lights :inline :offset-assert 48) +; (distance vector :inline :offset-assert 160) +; (next-tag dma-packet :inline :offset-assert 176) +; (dma-buf basic :offset-assert 192) +; (sink-group basic :offset-assert 196) +; (next-pris dma-packet :offset-assert 200) +; (next-merc dma-packet :offset-assert 204) +; (wait-count uint32 :offset-assert 208) +; (in-count uint32 :offset-assert 212) +; (sp-size uint32 :offset-assert 216) +; (sp-bufnum uint32 :offset-assert 220) +; (regs bone-regs :inline :offset-assert 224) +; ) +; :method-count-assert 9 +; :size-assert #xec +; :flag-assert #x9000000ec +; ) + +; ;; bones-h +; (deftype bone-debug (structure) +; ((time-ctr uint32 :offset-assert 0) +; (timing UNKNOWN 360 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x5a4 +; :flag-assert #x9000005a4 +; ) + +; ;; bones-h +; (deftype bone-memory (structure) +; ((work bone-work :inline :offset-assert 0) +; (buffer UNKNOWN 2 :offset-assert 240) +; (dma-list dma-packet :inline :offset-assert 240) +; ) +; :method-count-assert 9 +; :size-assert #x24f0 +; :flag-assert #x9000024f0 +; ) + +; ;; bones-h +; (deftype merc-globals (structure) +; ((first uint32 :offset-assert 0) +; (next uint32 :offset-assert 4) +; (sink basic :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; bones-h +; (deftype merc-global-array (structure) +; ((count uint32 :offset-assert 0) +; (globals UNKNOWN 8 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x84 +; :flag-assert #x900000084 +; ) + +; ;; bones-h +; (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 +; ) + +;; res-h +(deftype res-lump (basic) + ((length int32 :offset-assert 4) + (allocated-length int32 :offset-assert 8) + (data-base uint32 :offset-assert 12) + (data-top uint32 :offset-assert 16) + (data-size int32 :offset-assert 20) + (extra basic :offset-assert 24) + (tag uint32 :offset-assert 28) + ) + :method-count-assert 22 + :size-assert #x20 + :flag-assert #x1600000020 + ;; field extra is a basic loaded with a signed load + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + ) + ) + +; ;; res +; (deftype res-lump (basic) +; () +; :method-count-assert 22 +; :size-assert #x20 +; :flag-assert #x1600000020 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +;; dynamics-h +(deftype dynamics (basic) + ((name basic :offset-assert 4) + (gravity-max float :offset-assert 8) ;; meters + (gravity-length float :offset-assert 12) ;; meters + (gravity vector :inline :offset-assert 16) + (gravity-normal vector :inline :offset-assert 32) + (walk-distance float :offset-assert 48) ;meters + (run-distance float :offset-assert 52) ; meters + ) + :method-count-assert 9 + :size-assert #x38 + :flag-assert #x900000038 + ) + +;; surface-h +(deftype surface (basic) + ((name basic :offset-assert 4) + ;(data UNKNOWN 30 :offset-assert 8) + (turnv float :offset-assert 8) + (turnvv float :offset-assert 12) + (tiltv float :offset-assert 16) + (tiltvv float :offset-assert 20) + (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) + ;(hook UNKNOWN 4 :offset-assert 128) + (active-hook basic :offset 128) + (touch-hook basic :offset-assert 132) + (impact-hook basic :offset-assert 136) + (mult-hook basic :offset-assert 140) + ;(dataw UNKNOWN 2 :offset-assert 144) + (mode basic :offset-assert 144) + (flags uint32 :offset-assert 148) + ) + :method-count-assert 9 + :size-assert #x98 + :flag-assert #x900000098 + ) + +; ;; pat-h +; (deftype pat-surface (uint32) +; () +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ;; likely a bitfield type +; ) + +;; pat-h +(deftype pat-mode-info (structure) + ((name basic :offset-assert 0) + (wall-angle float :offset-assert 4) + (color uint32 :offset-assert 8) + (hilite-color uint32 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; 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 uint64 :offset-assert 16) ; usec + (eco-full-timeout uint64 :offset-assert 24) ; usec + (dummy uint64 :offset-assert 32) ; usec + (health-max-default float :offset-assert 40) + (health-single-inc float :offset-assert 44) + (eco-pill-max-default float :offset-assert 48) + (health-small-inc float :offset-assert 52) + (buzzer-max-default float :offset-assert 56) + (buzzer-single-inc float :offset-assert 60) + (suck-bounce-dist float :offset-assert 64) ; meters + (suck-suck-dist float :offset-assert 68) ; meters + (default-pill-inc float :offset-assert 72) + ) + :method-count-assert 9 + :size-assert #x4c + :flag-assert #x90000004c + ) + +;; fact-h +(deftype fact-info (basic) + ((process basic :offset-assert 4) + (pickup-type int32 :offset-assert 8) + (pickup-amount float :offset-assert 12) + (pickup-spawn-amount float :offset-assert 16) + (options uint64 :offset-assert 24) + (fade-time uint64 :offset-assert 32) + ) + :method-count-assert 12 + :size-assert #x28 + :flag-assert #xc00000028 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + ) + ) + +;; fact-h +(deftype fact-info-target (fact-info) + ((eco-type int32 :offset-assert 40) + (eco-level float :offset-assert 44) + (eco-pickup-time uint64 :offset-assert 48) + (eco-timeout uint64 :offset-assert 56) ;; usec + (health float :offset-assert 64) + (health-max float :offset-assert 68) + (buzzer float :offset-assert 72) + (buzzer-max float :offset-assert 76) + (eco-pill float :offset-assert 80) + (eco-pill-max float :offset-assert 84) + (health-pickup-time uint64 :offset-assert 88) + (eco-source uint64 :offset-assert 96) + (eco-source-time uint64 :offset-assert 104) + (money-pickup-time uint64 :offset-assert 112) + (buzzer-pickup-time uint64 :offset-assert 120) + (fuel-cell-pickup-time uint64 :offset-assert 128) + (eco-pill-pickup-time uint64 :offset-assert 136) + ) + :method-count-assert 12 + :size-assert #x90 + :flag-assert #xc00000090 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + ) + ) + +;; fact-h +(deftype fact-info-enemy (fact-info) + ((speed float :offset-assert 40) + (idle-distance float :offset-assert 44) ; meters + (notice-top float :offset-assert 48) ; meters + (notice-bottom float :offset-assert 52) ; meters + (cam-horz float :offset-assert 56) ; meters + (cam-vert float :offset-assert 60) ; meters + (cam-notice-dist float :offset-assert 64) ; meters + ) + :method-count-assert 12 + :size-assert #x44 + :flag-assert #xc00000044 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + ) + ) + +; ;; aligner-h +; (deftype align-control (basic) +; ((flags uint32 :offset-assert 4) +; (process basic :offset-assert 8) +; (frame-group basic :offset-assert 12) +; (frame-num float :offset-assert 16) +; (matrix UNKNOWN 2 :offset-assert 32) +; (transform UNKNOWN 2 :offset-assert 160) +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +;; game-h +(deftype process-drawable (process) + ((root basic :offset-assert 112) + (node-list basic :offset-assert 116) + (draw basic :offset-assert 120) + (skel basic :offset-assert 124) + (nav basic :offset-assert 128) + (align basic :offset-assert 132) + (path basic :offset-assert 136) + (vol basic :offset-assert 140) + (fact basic :offset-assert 144) + (link basic :offset-assert 148) + (part basic :offset-assert 152) + (water basic :offset-assert 156) + (sound basic :offset-assert 160) + (state-flags uint32 :offset-assert 164) + (state-time uint64 :offset-assert 168) + ) + :heap-base #x40 + :method-count-assert 20 + :size-assert #xb0 + :flag-assert #x14004000b0 + ;; inherited inpspect of process + (:methods + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + ) + ) + +; ;; game-h +; (deftype process-drawable-reserved (process-drawable) +; () +; :method-count-assert 63 +; :size-assert #xb0 +; :flag-assert #x3f004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; ) +; ) + +; ;; game-h +; (deftype attack-info (structure) +; ((trans vector :inline :offset-assert 0) +; (vector vector :inline :offset-assert 16) +; (intersection vector :inline :offset-assert 32) +; (attacker handle :offset-assert 48) +; (invinc-time uint64 :offset-assert 56) +; (mask uint32 :offset-assert 64) +; (mode basic :offset-assert 68) +; (shove-back meters :offset-assert 72) +; (shove-up meters :offset-assert 76) +; (speed meters :offset-assert 80) +; (dist meters :offset-assert 84) +; (control float :offset-assert 88) +; (angle basic :offset-assert 92) +; (rotate-to deg :offset-assert 96) +; (prev-state basic :offset-assert 100) +; ) +; :method-count-assert 10 +; :size-assert #x68 +; :flag-assert #xa00000068 +; ;; field handle is likely a value type +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; game-h +; (deftype ground-tween-info (structure) +; ((chan UNKNOWN 3 :offset-assert 0) +; (blend UNKNOWN 3 :offset-assert 4) +; (group UNKNOWN 5 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x24 +; :flag-assert #x900000024 +; ) + +; ;; generic-obs-h +; (deftype manipy (process-drawable) +; ((~Tnew-trans-hook basic :offset-assert 176) +; (~Tcur-trans-hook basic :offset-assert 180) +; (~Tcur-event-hook basic :offset-assert 184) +; (~Tnew-joint-anim basic :offset-assert 188) +; (~Tnew-joint-anim-blend uint64 :offset-assert 192) +; (~Tanim-mode basic :offset-assert 200) +; (~Tcur-grab-handle uint64 :offset-assert 208) +; (~Tcur-target-handle uint64 :offset-assert 216) +; (~Told-grab-pos vector :inline :offset-assert 224) +; (~Tjoint UNKNOWN 4 :offset-assert 240) +; (~Tnew-post-hook basic :offset-assert 256) +; (~Tcur-post-hook basic :offset-assert 260) +; (~Tclone-copy-trans basic :offset-assert 264) +; (~Tshadow-backup basic :offset-assert 268) +; (~Tdraw? basic :offset-assert 272) +; ) +; :method-count-assert 20 +; :size-assert #x114 +; :flag-assert #x1400b00114 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; generic-obs-h +; (deftype part-spawner (process-drawable) +; ((~Tmode uint32 :offset-assert 176) +; (~Tenable basic :offset-assert 180) +; (~Tradius meters :offset-assert 184) +; (~Tworld-sphere sphere :inline :offset-assert 192) +; ) +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; generic-obs-h +; (deftype part-tracker (process) +; () +; :method-count-assert 14 +; :size-assert #xf8 +; :flag-assert #xe009000f8 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; generic-obs-h +; (deftype camera-tracker (process) +; ((~Tname basic :offset-assert 4) +; (~Tgrab-target uint64 :offset-assert 120) +; (~Tgrab-event basic :offset-assert 128) +; (~Trelease-event basic :offset-assert 132) +; (~Told-global-mask uint32 :offset-assert 136) +; (~Told-self-mask uint32 :offset-assert 140) +; (~Told-parent-mask uint32 :offset-assert 144) +; (~Tlook-at-target uint64 :offset-assert 152) +; (~Tpov-target uint64 :offset-assert 160) +; (~Twork-process uint64 :offset-assert 168) +; (~Tanim-process uint64 :offset-assert 176) +; (~Tstart-time uint64 :offset-assert 184) +; (~Tcallback basic :offset-assert 192) +; (~Tuserdata basic :offset-assert 196) +; (~Tmessage basic :offset-assert 200) +; (~Tborder-value basic :offset-assert 204) +; (~Tmask-to-clear uint32 :offset-assert 208) +; (~Tscript basic :offset-assert 212) +; (~Tscript-line basic :offset-assert 216) +; (~Tscript-func basic :offset-assert 220) +; ) +; :method-count-assert 15 +; :size-assert #xe0 +; :flag-assert #xf007000e0 +; ;; inherited inpspect of processfield ~Tuserdata is a basic loaded with a signed load +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; generic-obs-h +; (deftype touch-tracker (process-drawable) +; ((~Tduration uint64 :offset-assert 176) +; (~Ttarget uint64 :offset-assert 184) +; (~Tevent basic :offset-assert 192) +; (~Trun-function basic :offset-assert 196) +; (~Tcallback basic :offset-assert 200) +; (~Tevent-mode basic :offset-assert 204) +; ) +; :method-count-assert 20 +; :size-assert #xd0 +; :flag-assert #x14006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; generic-obs-h +; (deftype swingpole (process) +; ((~Troot basic :offset-assert 112) +; (~Tdir vector :inline :offset-assert 128) +; (~Trange meters :offset-assert 144) +; (~Tedge-length meters :offset-assert 148) +; ) +; :method-count-assert 14 +; :size-assert #x98 +; :flag-assert #xe00300098 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; generic-obs-h +; (deftype gui-query (structure) +; ((x-position int32 :offset-assert 0) +; (y-position int32 :offset-assert 4) +; (message basic :offset-assert 8) +; (decision basic :offset-assert 12) +; (only-allow-cancel basic :offset-assert 16) +; (no-msg basic :offset-assert 20) +; (message-space int32 :offset-assert 24) +; ) +; :method-count-assert 11 +; :size-assert #x1c +; :flag-assert #xb0000001c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; generic-obs-h +; (deftype othercam (process) +; ((~Thand uint64 :offset-assert 112) +; (~Told-global-mask uint32 :offset-assert 120) +; (~Tmask-to-clear uint32 :offset-assert 124) +; (~Tcam-joint-index int32 :offset-assert 128) +; (~Told-pos vector :inline :offset-assert 144) +; (~Told-mat-z vector :inline :offset-assert 160) +; (~Thad-valid-frame basic :offset-assert 176) +; (~Tborder-value basic :offset-assert 180) +; (~Tdie? basic :offset-assert 184) +; (~Tsurvive-anim-end? basic :offset-assert 188) +; (~Tspooling? basic :offset-assert 192) +; ) +; :method-count-assert 14 +; :size-assert #xc4 +; :flag-assert #xe006000c4 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; generic-obs-h +; (deftype process-hidden (process) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; pov-camera-h +; (deftype pov-camera (process-drawable) +; ((~Tflags int32 :offset-assert 176) +; (~Tdebounce-start-time uint64 :offset-assert 184) +; (~Tnotify-handle uint64 :offset-assert 192) +; (~Tanim-name basic :offset-assert 200) +; (~Tcommand-list basic :offset-assert 204) +; (~Tmask-to-clear uint32 :offset-assert 208) +; (~Tmusic-volume-movie float :offset-assert 212) +; (~Tsfx-volume-movie float :offset-assert 216) +; ) +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; sync-info-h +; (deftype sync-info (structure) +; ((offset float :offset-assert 0) +; (period uint32 :offset-assert 4) +; ) +; :method-count-assert 18 +; :size-assert #x8 +; :flag-assert #x1200000008 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; sync-info-h +; (deftype sync-info-eased (sync-info) +; ((offset float :offset-assert 0) +; (period uint32 :offset-assert 4) +; (tlo float :offset-assert 8) +; (thi float :offset-assert 12) +; (ylo float :offset-assert 16) +; (m2 float :offset-assert 20) +; (yend float :offset-assert 24) +; ) +; :method-count-assert 18 +; :size-assert #x1c +; :flag-assert #x120000001c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; sync-info-h +; (deftype sync-info-paused (sync-info) +; ((offset float :offset-assert 0) +; (period uint32 :offset-assert 4) +; (pause-after-out float :offset-assert 8) +; (pause-after-in float :offset-assert 12) +; ) +; :method-count-assert 18 +; :size-assert #x10 +; :flag-assert #x1200000010 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; sync-info-h +; (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) +; (value float :offset-assert 24) +; ) +; :method-count-assert 11 +; :size-assert #x1c +; :flag-assert #xb0000001c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; sync-info-h +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; sync-info-h +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; sync-info-h +; (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) +; (value vector :inline :offset-assert 32) +; ) +; :method-count-assert 13 +; :size-assert #x30 +; :flag-assert #xd00000030 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; sync-info-h +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; smush-control-h +; (deftype smush-control (structure) +; ((start-time uint64 :offset-assert 0) +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; 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 16 +; :size-assert #x28 +; :flag-assert #x1000000028 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; ) +; ) + +; ;; debug-h +; (deftype pos-history (structure) +; ((points uint32 :offset-assert 0) +; (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 +; ) + +; ;; debug-h +; (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 +; ) + +; ;; debug-h +; (deftype debug-vertex-stats (basic) +; ((length int32 :offset-assert 4) +; (pos-count int32 :offset-assert 8) +; (vertex UNKNOWN 600 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x4b10 +; :flag-assert #x900004b10 +; ) + +; ;; joint-mod-h +; (deftype joint-mod (basic) +; ((mode uint32 :offset-assert 4) +; (process basic :offset-assert 8) +; (joint cspace :offset-assert 12) +; (target vector :inline :offset-assert 16) +; (twist vector :inline :offset-assert 32) +; (twist-max vector :inline :offset-assert 48) +; (trans vector :inline :offset-assert 64) +; (quat quaternion :inline :offset-assert 80) +; (scale vector :inline :offset-assert 96) +; (notice-time uint64 :offset-assert 112) +; (flex-blend float :offset-assert 120) +; (blend float :offset-assert 124) +; (max-dist meters :offset-assert 128) +; (ignore-angle deg :offset-assert 132) +; (up uint8 :offset-assert 136) +; (nose uint8 :offset-assert 137) +; (ear uint8 :offset-assert 138) +; (shutting-down? basic :offset-assert 140) +; (parented-scale? basic :offset-assert 128) +; ) +; :method-count-assert 16 +; :size-assert #x90 +; :flag-assert #x1000000090 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; ) +; ) + +; ;; joint-mod-h +; (deftype try-to-look-at-info (basic) +; ((who uint64 :offset-assert 8) +; (horz float :offset-assert 16) +; (vert float :offset-assert 20) +; ) +; :method-count-assert 9 +; :size-assert #x18 +; :flag-assert #x900000018 +; ) + +; ;; joint-mod-h +; (deftype joint-mod-wheel (basic) +; ((last-position vector :inline :offset-assert 16) +; (angle float :offset-assert 32) +; (process basic :offset-assert 36) +; (wheel-radius float :offset-assert 40) +; (wheel-axis int8 :offset-assert 44) +; ) +; :method-count-assert 9 +; :size-assert #x2d +; :flag-assert #x90000002d +; ) + +; ;; joint-mod-h +; (deftype joint-mod-set-local (basic) +; ((transform transformq :inline :offset-assert 16) +; (set-rotation basic :offset-assert 64) +; (set-scale basic :offset-assert 68) +; (set-translation basic :offset-assert 72) +; (enable basic :offset-assert 76) +; ) +; :method-count-assert 9 +; :size-assert #x50 +; :flag-assert #x900000050 +; ) + +; ;; joint-mod-h +; (deftype joint-mod-set-world (basic) +; ((transform transformq :inline :offset-assert 16) +; (node-index int32 :offset-assert 64) +; (enable basic :offset-assert 68) +; ) +; :method-count-assert 9 +; :size-assert #x48 +; :flag-assert #x900000048 +; ) + +; ;; joint-mod-h +; (deftype joint-mod-blend-local (basic) +; ((transform transformq :inline :offset-assert 16) +; (blend-transform transformq :inline :offset-assert 64) +; (node-index int32 :offset-assert 112) +; (blend float :offset-assert 116) +; (enable basic :offset-assert 120) +; ) +; :method-count-assert 9 +; :size-assert #x7c +; :flag-assert #x90000007c +; ) + +; ;; joint-mod-h +; (deftype joint-mod-spinner (basic) +; ((spin-axis vector :inline :offset-assert 16) +; (angle float :offset-assert 32) +; (spin-rate float :offset-assert 36) +; (enable basic :offset-assert 40) +; ) +; :method-count-assert 9 +; :size-assert #x2c +; :flag-assert #x90000002c +; ) + +; ;; collide-mesh-h +; (deftype collide-tri-result (structure) +; ((vertex UNKNOWN 3 :offset-assert 0) +; (intersect vector :inline :offset-assert 48) +; (normal vector :inline :offset-assert 64) +; (pat uint32 :offset-assert 80) +; ) +; :method-count-assert 9 +; :size-assert #x54 +; :flag-assert #x900000054 +; ) + +; ;; collide-mesh-h +; (deftype collide-mesh-tri (structure) +; ((vertex-index UNKNOWN 3 :offset-assert 0) +; (unused uint8 :offset-assert 3) +; (pat uint32 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; collide-mesh-h +; (deftype collide-mesh (basic) +; ((joint-id int32 :offset-assert 4) +; (num-tris uint32 :offset-assert 8) +; (num-verts uint32 :offset-assert 12) +; (vertex-data uint32 :offset-assert 16) +; (tris UNKNOWN 1 :offset-assert 32) +; ) +; :method-count-assert 16 +; :size-assert #x28 +; :flag-assert #x1000000028 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; ) +; ) + +; ;; collide-mesh-h +; (deftype collide-mesh-cache (basic) +; ((used-size uint32 :offset-assert 4) +; (max-size uint32 :offset-assert 8) +; (id uint64 :offset-assert 16) +; (data UNKNOWN 40960 :offset-assert 32) +; ) +; :method-count-assert 12 +; :size-assert #xa020 +; :flag-assert #xc0000a020 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; collide-mesh-h +; (deftype collide-mesh-cache-tri (structure) +; ((vertex UNKNOWN 3 :offset-assert 0) +; (normal vector :inline :offset-assert 48) +; (bbox4w bounding-box4w :inline :offset-assert 64) +; (pat uint32 :offset-assert 60) +; ) +; :method-count-assert 9 +; :size-assert #x60 +; :flag-assert #x900000060 +; ) + +; ;; collide-shape-h +; (deftype collide-sticky-rider (structure) +; ((rider-handle uint64 :offset-assert 0) +; (sticky-prim basic :offset-assert 8) +; (prim-ry float :offset-assert 12) +; (rider-local-pos vector :inline :offset-assert 16) +; ) +; :method-count-assert 10 +; :size-assert #x20 +; :flag-assert #xa00000020 +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; collide-shape-h +; (deftype collide-sticky-rider-group (basic) +; ((num-riders int32 :offset-assert 4) +; (allocated-riders int32 :offset-assert 8) +; (rider UNKNOWN 1 :offset-assert 16) +; ) +; :method-count-assert 11 +; :size-assert #x30 +; :flag-assert #xb00000030 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; collide-shape-h +; (deftype pull-rider-info (structure) +; ((rider collide-sticky-rider :offset-assert 0) +; (rider-cshape basic :offset-assert 4) +; (rider-delta-ry float :offset-assert 8) +; (rider-dest vector :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; collide-shape-h +; (deftype collide-shape-intersect (basic) +; ((move-vec vector :inline :offset-assert 16) +; (best-u float :offset-assert 32) +; (best-tri collide-tri-result :inline :offset-assert 48) +; (best-from-prim basic :offset-assert 132) +; (best-to-prim basic :offset-assert 136) +; ) +; :method-count-assert 10 +; :size-assert #x8c +; :flag-assert #xa0000008c +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; collide-shape-h +; (deftype collide-overlap-result (structure) +; ((best-dist float :offset-assert 0) +; (best-from-prim basic :offset-assert 4) +; (best-to-prim basic :offset-assert 8) +; (best-from-tri collide-tri-result :inline :offset-assert 16) +; ) +; :method-count-assert 10 +; :size-assert #x64 +; :flag-assert #xa00000064 +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; collide-shape-h +; (deftype overlaps-others-params (structure) +; ((options uint32 :offset-assert 0) +; (tlist basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; collide-shape-h +; (deftype collide-prim-core (structure) +; ((world-sphere vector :inline :offset-assert 0) +; (collide-as uint64 :offset-assert 16) +; (action uint32 :offset-assert 24) +; (offense int8 :offset-assert 28) +; (prim-type int8 :offset-assert 29) +; (extra UNKNOWN 2 :offset-assert 30) +; (quad UNKNOWN 2 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; collide-shape-h +; (deftype collide-shape-prim (basic) +; ((cshape basic :offset-assert 4) +; (prim-id uint32 :offset-assert 8) +; (transform-index int8 :offset-assert 12) +; (prim-core collide-prim-core :inline :offset-assert 16) +; (local-sphere vector :inline :offset-assert 48) +; (collide-with uint64 :offset-assert 64) +; (world-sphere vector :inline :offset-assert 16) +; (collide-as uint64 :offset-assert 32) +; (action uint32 :offset-assert 40) +; (offense int8 :offset-assert 44) +; (prim-type int8 :offset-assert 45) +; (radius meters :offset-assert 60) +; ) +; :method-count-assert 28 +; :size-assert #x48 +; :flag-assert #x1c00000048 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + +; ;; collide-shape-h +; (deftype collide-shape-prim-sphere (collide-shape-prim) +; ((cshape basic :offset-assert 4) +; (prim-id uint32 :offset-assert 8) +; (transform-index int8 :offset-assert 12) +; (prim-core collide-prim-core :inline :offset-assert 16) +; (local-sphere vector :inline :offset-assert 48) +; (collide-with uint64 :offset-assert 64) +; (world-sphere vector :inline :offset-assert 16) +; (collide-as uint64 :offset-assert 32) +; (action uint32 :offset-assert 40) +; (offense int8 :offset-assert 44) +; (prim-type int8 :offset-assert 45) +; (radius meters :offset-assert 60) +; (pat uint32 :offset-assert 72) +; ) +; :method-count-assert 28 +; :size-assert #x4c +; :flag-assert #x1c0000004c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + +; ;; collide-shape-h +; (deftype collide-shape-prim-mesh (collide-shape-prim) +; ((cshape basic :offset-assert 4) +; (prim-id uint32 :offset-assert 8) +; (transform-index int8 :offset-assert 12) +; (prim-core collide-prim-core :inline :offset-assert 16) +; (local-sphere vector :inline :offset-assert 48) +; (collide-with uint64 :offset-assert 64) +; (world-sphere vector :inline :offset-assert 16) +; (collide-as uint64 :offset-assert 32) +; (action uint32 :offset-assert 40) +; (offense int8 :offset-assert 44) +; (prim-type int8 :offset-assert 45) +; (radius meters :offset-assert 60) +; (mesh basic :offset-assert 72) +; (mesh-id int32 :offset-assert 76) +; (mesh-cache-id uint64 :offset-assert 80) +; (mesh-cache-tris uint32 :offset-assert 88) +; ) +; :method-count-assert 29 +; :size-assert #x5c +; :flag-assert #x1d0000005c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; collide-shape-h +; (deftype collide-shape-prim-group (collide-shape-prim) +; ((cshape basic :offset-assert 4) +; (prim-id uint32 :offset-assert 8) +; (transform-index int8 :offset-assert 12) +; (prim-core collide-prim-core :inline :offset-assert 16) +; (local-sphere vector :inline :offset-assert 48) +; (collide-with uint64 :offset-assert 64) +; (world-sphere vector :inline :offset-assert 16) +; (collide-as uint64 :offset-assert 32) +; (action uint32 :offset-assert 40) +; (offense int8 :offset-assert 44) +; (prim-type int8 :offset-assert 45) +; (radius meters :offset-assert 60) +; (num-prims int32 :offset-assert 72) +; (allocated-prims int32 :offset-assert 76) +; (prim UNKNOWN 1 :offset-assert 80) +; ) +; :method-count-assert 30 +; :size-assert #x54 +; :flag-assert #x1e00000054 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; collide-shape-h +; (deftype collide-shape (trsqv) +; ((trans vector :inline :offset-assert 16) +; (rot vector :inline :offset-assert 32) +; (scale vector :inline :offset-assert 48) +; (quat quaternion :inline :offset-assert 32) +; (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) +; (old-y-angle-diff float :offset-assert 136) +; (process basic :offset-assert 140) +; (max-iteration-count uint8 :offset-assert 144) +; (nav-flags uint8 :offset-assert 145) +; (pad-byte UNKNOWN 2 :offset-assert 146) +; (pat-ignore-mask uint32 :offset-assert 148) +; (event-self basic :offset-assert 152) +; (event-other basic :offset-assert 156) +; (root-prim basic :offset-assert 160) +; (riders basic :offset-assert 164) +; (backup-collide-as uint64 :offset-assert 168) +; (backup-collide-with uint64 :offset-assert 176) +; ) +; :method-count-assert 56 +; :size-assert #xb8 +; :flag-assert #x38000000b8 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; ) +; ) + +; ;; collide-shape-h +; (deftype collide-shape-moving (collide-shape) +; ((trans vector :inline :offset-assert 16) +; (rot vector :inline :offset-assert 32) +; (scale vector :inline :offset-assert 48) +; (quat quaternion :inline :offset-assert 32) +; (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) +; (old-y-angle-diff float :offset-assert 136) +; (process basic :offset-assert 140) +; (max-iteration-count uint8 :offset-assert 144) +; (nav-flags uint8 :offset-assert 145) +; (pad-byte UNKNOWN 2 :offset-assert 146) +; (pat-ignore-mask uint32 :offset-assert 148) +; (event-self basic :offset-assert 152) +; (event-other basic :offset-assert 156) +; (root-prim basic :offset-assert 160) +; (riders basic :offset-assert 164) +; (backup-collide-as uint64 :offset-assert 168) +; (backup-collide-with uint64 :offset-assert 176) +; (rider-time uint64 :offset-assert 184) +; (rider-last-move vector :inline :offset-assert 192) +; (trans-old UNKNOWN 3 :offset-assert 208) +; (poly-pat uint32 :offset-assert 256) +; (cur-pat uint32 :offset-assert 260) +; (ground-pat uint32 :offset-assert 264) +; (status uint64 :offset-assert 272) +; (old-status uint64 :offset-assert 280) +; (prev-status uint64 :offset-assert 288) +; (reaction-flag uint32 :offset-assert 296) +; (reaction basic :offset-assert 300) +; (no-reaction basic :offset-assert 304) +; (local-normal vector :inline :offset-assert 320) +; (surface-normal vector :inline :offset-assert 336) +; (poly-normal vector :inline :offset-assert 352) +; (ground-poly-normal vector :inline :offset-assert 368) +; (ground-touch-point vector :inline :offset-assert 384) +; (shadow-pos vector :inline :offset-assert 400) +; (ground-impact-vel meters :offset-assert 416) +; (surface-angle float :offset-assert 420) +; (poly-angle float :offset-assert 424) +; (touch-angle float :offset-assert 428) +; (coverage float :offset-assert 432) +; (dynam basic :offset-assert 436) +; (surf basic :offset-assert 440) +; ) +; :method-count-assert 65 +; :size-assert #x1bc +; :flag-assert #x41000001bc +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; ) +; ) + +; ;; collide-target-h +; (deftype collide-history (structure) +; ((intersect vector :inline :offset-assert 0) +; (trans vector :inline :offset-assert 16) +; (transv vector :inline :offset-assert 32) +; (transv-out vector :inline :offset-assert 48) +; (local-normal vector :inline :offset-assert 64) +; (surface-normal vector :inline :offset-assert 80) +; (time uint64 :offset-assert 96) +; (status uint64 :offset-assert 104) +; (pat uint32 :offset-assert 112) +; (reaction-flag uint32 :offset-assert 116) +; ) +; :method-count-assert 10 +; :size-assert #x78 +; :flag-assert #xa00000078 +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; collide-touch-h +; (deftype touching-prim (structure) +; ((cprim basic :offset-assert 0) +; (has-tri? basic :offset-assert 4) +; (tri collide-tri-result :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x64 +; :flag-assert #x900000064 +; ) + +; ;; collide-touch-h +; (deftype touching-prims-entry (structure) +; ((next touching-prims-entry :offset-assert 0) +; (prev touching-prims-entry :offset-assert 4) +; (allocated? basic :offset-assert 8) +; (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 #xe4 +; :flag-assert #xd000000e4 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; collide-touch-h +; (deftype touching-prims-entry-pool (structure) +; ((head touching-prims-entry :offset-assert 0) +; (nodes UNKNOWN 64 :offset-assert 16) +; ) +; :method-count-assert 13 +; :size-assert #x3c10 +; :flag-assert #xd00003c10 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; collide-touch-h +; (deftype touching-shapes-entry (structure) +; ((cshape1 basic :offset-assert 0) +; (cshape2 basic :offset-assert 4) +; (resolve-u int8 :offset-assert 8) +; (head touching-prims-entry :offset-assert 12) +; ) +; :method-count-assert 18 +; :size-assert #x10 +; :flag-assert #x1200000010 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; collide-touch-h +; (deftype touching-list (structure) +; ((num-touching-shapes int32 :offset-assert 0) +; (resolve-u int8 :offset-assert 4) +; (touching-shapes UNKNOWN 32 :offset-assert 8) +; ) +; :method-count-assert 15 +; :size-assert #x208 +; :flag-assert #xf00000208 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; collide-edge-grab-h +; (deftype edge-grab-info (structure) +; ((world-vertex UNKNOWN 6 :offset-assert 0) +; (local-vertex UNKNOWN 6 :offset-assert 96) +; (actor-cshape-prim-offset int32 :offset-assert 192) +; (actor-handle uint64 :offset-assert 200) +; (hanging-matrix matrix :inline :offset-assert 208) +; (edge-vertex UNKNOWN 2 :offset-assert 0) +; (center-hold vector :inline :offset-assert 32) +; (tri-vertex UNKNOWN 3 :offset-assert 48) +; (left-hand-hold vector :inline :offset-assert 272) +; (right-hand-hold vector :inline :offset-assert 288) +; (center-hold-old vector :inline :offset-assert 304) +; (edge-tri-pat uint32 :offset-assert 320) +; ) +; :method-count-assert 11 +; :size-assert #x144 +; :flag-assert #xb00000144 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; collide-edge-grab-h +; (deftype collide-edge-tri (structure) +; ((ctri collide-cache-tri :offset-assert 0) +; (normal vector :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; collide-edge-grab-h +; (deftype collide-edge-edge (structure) +; ((ignore basic :offset-assert 0) +; (etri collide-edge-tri :offset-assert 4) +; (vertex-ptr UNKNOWN 2 :offset-assert 8) +; (outward vector :inline :offset-assert 16) +; (edge-vec-norm vector :inline :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; collide-edge-grab-h +; (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 +; ) + +; ;; collide-edge-grab-h +; (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 UNKNOWN 32 :offset-assert 16) +; (attempts UNKNOWN 32 :offset-assert 1552) +; ) +; :method-count-assert 11 +; :size-assert #x810 +; :flag-assert #xb00000810 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; collide-edge-grab-h +; (deftype collide-edge-work (structure) +; ((ccache basic :offset-assert 0) +; (cshape basic :offset-assert 4) +; (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) +; (max-dist-sqrd-to-outward-pt float :offset-assert 160) +; (max-dir-cosa-delta float :offset-assert 164) +; (split-dists UNKNOWN 2 :offset-assert 168) +; (outward-offset vector :inline :offset-assert 176) +; (local-cache-fill-box bounding-box :inline :offset-assert 192) +; (local-within-reach-box bounding-box :inline :offset-assert 224) +; (local-player-spheres UNKNOWN 12 :offset-assert 256) +; (world-player-spheres UNKNOWN 12 :offset-assert 448) +; (local-player-hanging-spheres UNKNOWN 6 :offset-assert 256) +; (world-player-hanging-spheres UNKNOWN 6 :offset-assert 448) +; (local-player-leap-up-spheres UNKNOWN 6 :offset-assert 352) +; (world-player-leap-up-spheres UNKNOWN 6 :offset-assert 544) +; (verts UNKNOWN 64 :offset-assert 640) +; (edges UNKNOWN 96 :offset-assert 1664) +; (tris UNKNOWN 48 :offset-assert 6272) +; (hold-list collide-edge-hold-list :inline :offset-assert 7808) +; ) +; :method-count-assert 20 +; :size-assert #x2690 +; :flag-assert #x1400002690 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; effect-control-h +; (deftype effect-control (basic) +; ((process basic :offset-assert 4) +; (flags uint32 :offset-assert 8) +; (last-frame-group basic :offset-assert 12) +; (last-frame-num float :offset-assert 16) +; (channel-offset int32 :offset-assert 20) +; (res basic :offset-assert 24) +; (name uint32 :offset-assert 28) +; (param uint32 :offset-assert 32) +; ) +; :method-count-assert 15 +; :size-assert #x24 +; :flag-assert #xf00000024 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; collide-frag-h +; (deftype collide-frag-vertex (vector) +; ((data UNKNOWN 4 :offset-assert 0) +; (x float :offset-assert 0) +; (y float :offset-assert 4) +; (z float :offset-assert 8) +; (w float :offset-assert 12) +; (quad uint128 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; collide-frag-h +; (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 vector :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 +; ) + +; ;; collide-frag-h +; (deftype collide-fragment (drawable) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (mesh basic :offset-assert 8) +; ) +; :method-count-assert 18 +; :size-assert #x20 +; :flag-assert #x1200000020 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; collide-frag-h +; (deftype drawable-inline-array-collide-fragment (drawable-inline-array) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (length int16 :offset-assert 6) +; (data UNKNOWN 1 :offset-assert 36) +; ) +; :method-count-assert 18 +; :size-assert #x44 +; :flag-assert #x1200000044 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; projectiles-h +; (deftype projectile (process-drawable) +; ((~Tbase-trans vector :inline :offset-assert 176) +; (~Ttarget vector :inline :offset-assert 192) +; (~Ttarget-base vector :inline :offset-assert 208) +; (~Tparent-base vector :inline :offset-assert 224) +; (~Tparent-quat vector :inline :offset-assert 240) +; (~Tbase-vector vector :inline :offset-assert 256) +; (~Ttimeout uint64 :offset-assert 272) +; (~Toptions uint64 :offset-assert 280) +; (~Tlast-target uint64 :offset-assert 288) +; (~Tnotify-handle uint64 :offset-assert 296) +; (~Tmax-speed float :offset-assert 304) +; (~Tmax-turn float :offset-assert 308) +; (~Told-dist UNKNOWN 16 :offset-assert 312) +; (~Told-dist-count int32 :offset-assert 376) +; (~Thits int32 :offset-assert 380) +; (~Tmax-hits int32 :offset-assert 384) +; (~Ttween float :offset-assert 388) +; (~Tattack-mode basic :offset-assert 392) +; (~Tupdate-velocity basic :offset-assert 396) +; (~Tcounter int32 :offset-assert 400) +; (~Ttarget-count int32 :offset-assert 404) +; (~Tsound-id uint32 :offset-assert 408) +; ) +; :method-count-assert 29 +; :size-assert #x19c +; :flag-assert #x1d0130019c +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; projectiles-h +; (deftype projectile-yellow (projectile) +; ((~Tmode int32 :offset-assert 412) +; (~Tangle float :offset-assert 416) +; ) +; :method-count-assert 29 +; :size-assert #x1a4 +; :flag-assert #x1d014001a4 +; ;; inherited inpspect of projectile +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; projectiles-h +; (deftype projectile-blue (projectile) +; ((~Tmode int32 :offset-assert 412) +; (~Tjoint-num int32 :offset-assert 416) +; ) +; :method-count-assert 29 +; :size-assert #x1a4 +; :flag-assert #x1d014001a4 +; ;; inherited inpspect of projectile +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; target-h +; (deftype target (process-drawable) +; ((~Tcontrol basic :offset-assert 112) +; (~Tskel2 basic :offset-assert 176) +; (~Tracer basic :offset-assert 180) +; (~Tgame basic :offset-assert 184) +; (~Tneck basic :offset-assert 188) +; (~Tstate-hook-time uint64 :offset-assert 192) +; (~Tstate-hook basic :offset-assert 200) +; (~Tcam-user-mode basic :offset-assert 204) +; (~Tsidekick uint32 :offset-assert 208) +; (~Tmanipy uint32 :offset-assert 212) +; (~Tattack-info attack-info :inline :offset-assert 224) +; (~Tattack-info-rec attack-info :inline :offset-assert 336) +; (~Tanim-seed uint64 :offset-assert 440) +; (~Talt-cam-pos vector :inline :offset-assert 448) +; (~Tsnowball basic :offset-assert 464) +; (~Ttube basic :offset-assert 468) +; (~Tflut basic :offset-assert 472) +; (~Tcurrent-level basic :offset-assert 476) +; (~Tsaved-pos transformq :inline :offset-assert 480) +; (~Tsaved-owner uint64 :offset-assert 528) +; (~Talt-neck-pos vector :inline :offset-assert 544) +; (~Tfp-hud uint64 :offset-assert 560) +; (~Tno-load-wait uint64 :offset-assert 568) +; (~Tno-look-around-wait uint64 :offset-assert 576) +; ) +; :method-count-assert 21 +; :size-assert #x248 +; :flag-assert #x1501e00248 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; target-h +; (deftype sidekick (process-drawable) +; ((~Tcontrol basic :offset-assert 112) +; (~Tstate-time uint64 :offset-assert 168) +; (~Tstate-flags uint32 :offset-assert 164) +; (~Tanim-seed uint64 :offset-assert 192) +; (~Tshadow-in-movie? basic :offset-assert 200) +; ) +; :method-count-assert 20 +; :size-assert #xcc +; :flag-assert #x14006000cc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; depth-cue-h +; (deftype depth-cue-data (structure) +; ((data vector :inline :offset-assert 0) +; (sharpness float :offset-assert 0) +; (alpha float :offset-assert 4) +; (distance float :offset-assert 8) +; (w float :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; depth-cue-h +; (deftype depth-cue-work (structure) +; ((texture-strip-tmpl dma-gif-packet :inline :offset-assert 0) +; (temp-strip-tmpl dma-gif-packet :inline :offset-assert 32) +; (stencil-tmpl dma-gif-packet :inline :offset-assert 64) +; (clear-color vector4w :inline :offset-assert 96) +; (set-color vector4w :inline :offset-assert 112) +; (draw-color vector4w :inline :offset-assert 128) +; (depth depth-cue-data :offset-assert 144) +; (front depth-cue-data :offset-assert 148) +; ) +; :method-count-assert 9 +; :size-assert #x98 +; :flag-assert #x900000098 +; ) + +; ;; 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 +; ) + +; ;; stats-h +; (deftype merc-global-stats (structure) +; ((merc tr-stat :inline :offset-assert 0) +; (mercneric tr-stat :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; stats-h +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; stats-h +; (deftype perf-stat-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; bsp-h +; (deftype bsp-node (structure) +; ((front int32 :offset-assert 0) +; (back int32 :offset-assert 4) +; (front-flags uint32 :offset-assert 8) +; (back-flags uint32 :offset-assert 12) +; (plane vector :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; bsp-h +; (deftype game-level (basic) +; ((master-bsp basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; bsp-h +; (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 +; ) + +; ;; bsp-h +; (deftype bsp-header (drawable) +; () +; :method-count-assert 20 +; :size-assert #x190 +; :flag-assert #x1400000190 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; bsp-h +; (deftype cl-stat (structure) +; ((fragments uint32 :offset-assert 0) +; (tris uint32 :offset-assert 4) +; (output uint32 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; bsp-h +; (deftype collide-stats (structure) +; ((other cl-stat :inline :offset-assert 0) +; (total cl-stat :inline :offset-assert 12) +; (nodes uint32 :offset-assert 24) +; (calls uint32 :offset-assert 28) +; (total-target stopwatch :inline :offset-assert 36) +; (target-cache-fill stopwatch :inline :offset-assert 68) +; (target-ray-poly stopwatch :inline :offset-assert 100) +; ) +; :method-count-assert 9 +; :size-assert #x80 +; :flag-assert #x900000080 +; ) + +; ;; collide-cache-h +; (deftype collide-using-spheres-params (structure) +; ((spheres uint32 :offset-assert 0) +; (num-spheres uint32 :offset-assert 4) +; (collide-with uint64 :offset-assert 8) +; (proc basic :offset-assert 16) +; (ignore-pat uint32 :offset-assert 20) +; (solid-only basic :offset-assert 24) +; ) +; :method-count-assert 9 +; :size-assert #x1c +; :flag-assert #x90000001c +; ) + +; ;; 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 +; ) + +; ;; collide-cache-h +; (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 UNKNOWN 64 :offset-assert 96) +; ) +; :method-count-assert 11 +; :size-assert #xc60 +; :flag-assert #xb00000c60 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; collide-cache-h +; (deftype collide-puyp-work (structure) +; ((best-u float :offset-assert 0) +; (ignore-pat uint32 :offset-assert 4) +; (tri-out collide-tri-result :offset-assert 8) +; (start-pos vector :inline :offset-assert 16) +; (move-dist vector :inline :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; collide-cache-h +; (deftype collide-cache-tri (structure) +; ((vertex UNKNOWN 3 :offset-assert 0) +; (extra-quad UNKNOWN 16 :offset-assert 48) +; (pat uint32 :offset-assert 48) +; (prim-index uint16 :offset-assert 52) +; (user16 uint16 :offset-assert 54) +; (user32 UNKNOWN 2 :offset-assert 56) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; collide-cache-h +; (deftype collide-cache-prim (structure) +; ((prim-core collide-prim-core :inline :offset-assert 0) +; (extra-quad UNKNOWN 16 :offset-assert 32) +; (ccache basic :offset-assert 32) +; (prim basic :offset-assert 36) +; (first-tri uint16 :offset-assert 40) +; (num-tris uint16 :offset-assert 42) +; (unused UNKNOWN 4 :offset-assert 44) +; (world-sphere vector :inline :offset-assert 0) +; (collide-as uint64 :offset-assert 16) +; (action uint32 :offset-assert 24) +; (offense int8 :offset-assert 28) +; (prim-type int8 :offset-assert 29) +; ) +; :method-count-assert 11 +; :size-assert #x30 +; :flag-assert #xb00000030 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; collide-cache-h +; (deftype collide-cache (basic) +; ((num-tris int32 :offset-assert 4) +; (num-prims int32 :offset-assert 8) +; (ignore-mask uint32 :offset-assert 12) +; (proc basic :offset-assert 16) +; (collide-box bounding-box :inline :offset-assert 32) +; (collide-box4w bounding-box4w :inline :offset-assert 64) +; (collide-with uint64 :offset-assert 96) +; (prims UNKNOWN 100 :offset-assert 112) +; (tris UNKNOWN 461 :offset-assert 4912) +; ) +; :method-count-assert 33 +; :size-assert #x8670 +; :flag-assert #x2100008670 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; collide-cache-h +; (deftype collide-list-item (structure) +; ((mesh basic :offset-assert 0) +; (inst basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; collide-cache-h +; (deftype collide-list (structure) +; ((num-items int32 :offset-assert 0) +; (items UNKNOWN 256 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x1010 +; :flag-assert #x900001010 +; ) + +; ;; collide-cache-h +; (deftype collide-work (structure) +; ((collide-sphere-neg-r sphere :inline :offset-assert 0) +; (collide-box4w bounding-box4w :inline :offset-assert 16) +; (inv-mat matrix :inline :offset-assert 48) +; ) +; :method-count-assert 9 +; :size-assert #x70 +; :flag-assert #x900000070 +; ) + +; ;; shrubbery-h +; (deftype billboard (drawable) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (flat adgif-shader :inline :offset-assert 32) +; ) +; :method-count-assert 18 +; :size-assert #x70 +; :flag-assert #x1200000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; shrubbery-h +; (deftype shrub-view-data (structure) +; ((data UNKNOWN 3 :offset-assert 0) +; (texture-giftag qword :inline :offset-assert 0) +; (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 +; ) + +; ;; shrubbery-h +; (deftype shrubbery (drawable) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (textures uint32 :offset-assert 4) +; (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 18 +; :size-assert #x20 +; :flag-assert #x1200000020 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; shrubbery-h +; (deftype instance-shrubbery (instance) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (bucket-index uint16 :offset-assert 6) +; (origin matrix4h :inline :offset-assert 32) +; (wind-index uint16 :offset-assert 62) +; (flat-normal vector :inline :offset-assert 64) +; (flat-hwidth float :offset-assert 76) +; (color uint32 :offset-assert 8) +; ) +; :method-count-assert 18 +; :size-assert #x50 +; :flag-assert #x1200000050 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; shrubbery-h +; (deftype generic-shrub-fragment (drawable) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (textures uint32 :offset-assert 4) +; (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 18 +; :size-assert #x20 +; :flag-assert #x1200000020 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; shrubbery-h +; (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 +; ) + +; ;; shrubbery-h +; (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 UNKNOWN 8 :offset-assert 112) +; ) +; :method-count-assert 9 +; :size-assert #x90 +; :flag-assert #x900000090 +; ) + +; ;; shrubbery-h +; (deftype instance-shrub-work (structure) +; ((dummy UNKNOWN 3 :offset-assert 0) +; (chaina UNKNOWN 8 :offset-assert 48) +; (chainb UNKNOWN 8 :offset-assert 176) +; (colors UNKNOWN 1024 :offset-assert 304) +; (matrix-tmpl UNKNOWN 20 :offset-assert 4400) +; (count-tmpl UNKNOWN 20 :offset-assert 4720) +; (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 UNKNOWN 6 :offset-assert 5152) +; (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 UNKNOWN 4 :offset-assert 6208) +; (plane UNKNOWN 4 :offset-assert 6272) +; (last UNKNOWN 4 :offset-assert 6336) +; (next UNKNOWN 4 :offset-assert 6352) +; (count UNKNOWN 4 :offset-assert 6368) +; (mod-count UNKNOWN 4 :offset-assert 6376) +; (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 UNKNOWN 6 :offset-assert 6428) +; (length UNKNOWN 6 :offset-assert 6452) +; (prototypes uint32 :offset-assert 6476) +; (bucket-ptr uint32 :offset-assert 6404) +; (start-bank UNKNOWN 20 :offset-assert 6484) +; (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) +; (to-spr uint32 :offset-assert 6412) +; (dma-buffer basic :offset-assert 6524) +; (near-last uint32 :offset-assert 6528) +; (near-next uint32 :offset-assert 6532) +; (near-count uint32 :offset-assert 6536) +; (last-shrubs uint32 :offset-assert 6540) +; (chains uint32 :offset-assert 6544) +; (flags uint32 :offset-assert 6548) +; (paused basic :offset-assert 6552) +; (node-count uint32 :offset-assert 6556) +; (inst-count uint32 :offset-assert 6560) +; (wait-from-spr uint32 :offset-assert 6564) +; (wait-to-spr uint32 :offset-assert 6568) +; ) +; :method-count-assert 9 +; :size-assert #x19ac +; :flag-assert #x9000019ac +; ) + +; ;; shrubbery-h +; (deftype instance-shrub-dma (structure) +; ((instancea UNKNOWN 325 :offset-assert 0) +; (instanceb UNKNOWN 325 :offset-assert 5200) +; (outa UNKNOWN 128 :offset-assert 10400) +; (outb UNKNOWN 128 :offset-assert 12448) +; ) +; :method-count-assert 9 +; :size-assert #x38a0 +; :flag-assert #x9000038a0 +; ) + +; ;; tie-h +; (deftype tie-fragment (drawable) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (gif-ref uint32 :offset-assert 4) +; (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) +; (num-tris uint16 :offset-assert 40) +; (num-dverts uint16 :offset-assert 42) +; (dp-ref uint32 :offset-assert 44) +; (dp-qwc uint32 :offset-assert 48) +; (generic-ref uint32 :offset-assert 52) +; (generic-count uint32 :offset-assert 56) +; (debug-lines basic :offset-assert 60) +; ) +; :method-count-assert 18 +; :size-assert #x40 +; :flag-assert #x1200000040 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; tie-h +; (deftype instance-tie (instance) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (bucket-index uint16 :offset-assert 6) +; (origin matrix4h :inline :offset-assert 32) +; (wind-index uint16 :offset-assert 62) +; (color-indices uint32 :offset-assert 8) +; (bucket-ptr basic :offset-assert 12) +; (max-scale uint16 :offset-assert 38) +; (flags uint16 :offset-assert 46) +; ) +; :method-count-assert 18 +; :size-assert #x40 +; :flag-assert #x1200000040 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; tie-h +; (deftype drawable-tree-instance-tie (drawable-tree) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (length int16 :offset-assert 6) +; (data UNKNOWN 1 :offset-assert 32) +; (prototypes basic :offset-assert 8) +; ) +; :method-count-assert 18 +; :size-assert #x24 +; :flag-assert #x1200000024 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; tie-h +; (deftype tie-matrix (structure) +; ((mat matrix :inline :offset-assert 0) +; (morph qword :inline :offset-assert 64) +; (fog qword :inline :offset-assert 80) +; ) +; :method-count-assert 9 +; :size-assert #x60 +; :flag-assert #x900000060 +; ) + +; ;; tie-h +; (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 UNKNOWN 4 :offset-assert 128) +; (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) +; (tie-near-perspective-matrix matrix :inline :offset-assert 320) +; (wind-vectors uint32 :offset-assert 384) +; (test-id uint32 :offset-assert 388) +; (test-id2 uint32 :offset-assert 392) +; (dma-buffer basic :offset-assert 396) +; (to-spr uint32 :offset-assert 400) +; (from-spr uint32 :offset-assert 404) +; (wind-work uint32 :offset-assert 408) +; (cur-vis-bits uint32 :offset-assert 412) +; (end-vis-bits uint32 :offset-assert 416) +; (first-generic-prototype uint32 :offset-assert 420) +; (refl-fade-fac float :offset-assert 424) +; (refl-fade-end float :offset-assert 428) +; (flags uint32 :offset-assert 432) +; (paused basic :offset-assert 436) +; (wait-from-spr uint32 :offset-assert 440) +; (wait-to-spr uint32 :offset-assert 444) +; ) +; :method-count-assert 9 +; :size-assert #x1c0 +; :flag-assert #x9000001c0 +; ) + +; ;; tie-h +; (deftype instance-tie-dma (structure) +; ((banka UNKNOWN 32 :offset-assert 4) +; (bankb UNKNOWN 32 :offset-assert 2052) +; (outa UNKNOWN 256 :offset-assert 4096) +; (outb UNKNOWN 256 :offset-assert 8192) +; (work instance-tie-work :offset-assert 12288) +; ) +; :method-count-assert 9 +; :size-assert #x3000 +; :flag-assert #x900003000 +; ) + +; ;; tie-h +; (deftype prototype-tie-work (structure) +; ((upload-palette-0 dma-packet :inline :offset-assert 0) +; (upload-palette-1 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) +; (generic-envmap-shader dma-packet :inline :offset-assert 176) +; (generic-palette dma-packet :inline :offset-assert 192) +; (generic-model-0 dma-packet :inline :offset-assert 208) +; (generic-model-1 dma-packet :inline :offset-assert 224) +; (generic-model-2 dma-packet :inline :offset-assert 240) +; (generic-model-next dma-packet :inline :offset-assert 256) +; (clamp uint64 :offset-assert 272) +; (prototype-array basic :offset-assert 280) +; (generic-wait-from-spr uint32 :offset-assert 284) +; (generic-wait-to-spr uint32 :offset-assert 288) +; (wait-from-spr uint32 :offset-assert 292) +; (wait-to-spr uint32 :offset-assert 296) +; (near-wait-from-spr uint32 :offset-assert 300) +; (near-wait-to-spr uint32 :offset-assert 304) +; ) +; :method-count-assert 9 +; :size-assert #x134 +; :flag-assert #x900000134 +; ) + +; ;; tie-h +; (deftype prototype-tie-dma (structure) +; ((colora UNKNOWN 256 :offset-assert 0) +; (colorb UNKNOWN 256 :offset-assert 1024) +; (outa UNKNOWN 256 :offset-assert 2048) +; (outb UNKNOWN 256 :offset-assert 6144) +; (length uint32 :offset-assert 10240) +; (dma-buffer basic :offset-assert 10244) +; (this-frag-count uint32 :offset-assert 10248) +; (next UNKNOWN 4 :offset-assert 10256) +; (geometry UNKNOWN 4 :offset-assert 10272) +; (frag-count UNKNOWN 4 :offset-assert 10288) +; ) +; :method-count-assert 9 +; :size-assert #x2834 +; :flag-assert #x900002834 +; ) + +; ;; tfrag-h +; (deftype tfragment-stats (structure) +; ((num-tris UNKNOWN 4 :offset-assert 0) +; (num-dverts UNKNOWN 4 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; tfrag-h +; (deftype tfragment-debug-data (structure) +; ((stats tfragment-stats :inline :offset-assert 0) +; (debug-lines basic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; tfrag-h +; (deftype generic-tfragment (structure) +; ((dummy int32 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ) + +; ;; tfrag-h +; (deftype tfragment (drawable) +; ((id int16 :offset-assert 4) +; (bsphere vector :inline :offset-assert 16) +; (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 UNKNOWN 3 :offset-assert 32) +; (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 UNKNOWN 4 :offset-assert 44) +; (shader uint32 :offset-assert 48) +; (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) +; (pad0 uint8 :offset-assert 58) +; (pad1 uint8 :offset-assert 59) +; (generic generic-tfragment :offset-assert 60) +; ) +; :method-count-assert 18 +; :size-assert #x40 +; :flag-assert #x1200000040 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; tfrag-h +; (deftype tfrag-dists (structure) +; ((data UNKNOWN 16 :offset-assert 0) +; (vector UNKNOWN 4 :offset-assert 0) +; (k0s UNKNOWN 2 :offset-assert 0) +; (k1s UNKNOWN 2 :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; tfrag-h +; (deftype tfrag-data (structure) +; ((data UNKNOWN 56 :offset-assert 0) +; (vector UNKNOWN 14 :offset-assert 0) +; (fog vector :inline :offset-assert 0) +; (val vector :inline :offset-assert 16) +; (strgif qword :inline :offset-assert 32) +; (fangif qword :inline :offset-assert 48) +; (adgif qword :inline :offset-assert 64) +; (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 UNKNOWN 2 :offset-assert 160) +; (k1s UNKNOWN 2 :offset-assert 192) +; ) +; :method-count-assert 9 +; :size-assert #xe0 +; :flag-assert #x9000000e0 +; ) + +; ;; tfrag-h +; (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 +; ) + +; ;; tfrag-h +; (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 +; ) + +; ;; tfrag-h +; (deftype tfrag-packet (structure) +; ((tag UNKNOWN 2 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; tfrag-h +; (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) +; (max-dist vector :inline :offset-assert 96) +; (min-dist vector :inline :offset-assert 112) +; (color-ptr vector4w :inline :offset-assert 128) +; (tr-stat-tfrag tr-stat :offset-assert 144) +; (tr-stat-tfrag-near tr-stat :offset-assert 148) +; (vu1-enable-tfrag int32 :offset-assert 152) +; (vu1-enable-tfrag-near int32 :offset-assert 156) +; (cur-vis-bits uint32 :offset-assert 160) +; (end-vis-bits uint32 :offset-assert 164) +; (src-ptr uint32 :offset-assert 168) +; (last-call uint32 :offset-assert 172) +; (dma-buffer basic :offset-assert 176) +; (test-id uint32 :offset-assert 180) +; (wait-from-spr uint32 :offset-assert 184) +; (wait-to-spr uint32 :offset-assert 188) +; (near-wait-from-spr uint32 :offset-assert 192) +; (near-wait-to-spr uint32 :offset-assert 196) +; ) +; :method-count-assert 9 +; :size-assert #xc8 +; :flag-assert #x9000000c8 +; ) + +; ;; tfrag-h +; (deftype tfrag-dma (structure) +; ((banka UNKNOWN 16 :offset-assert 4) +; (bankb UNKNOWN 16 :offset-assert 1028) +; (outa UNKNOWN 128 :offset-assert 2048) +; (outb UNKNOWN 128 :offset-assert 4096) +; (colors UNKNOWN 2048 :offset-assert 6144) +; ) +; :method-count-assert 9 +; :size-assert #x37fc +; :flag-assert #x9000037fc +; ) + +; ;; background-h +; (deftype background-work (basic) +; ((tfrag-tree-count int32 :offset-assert 4) +; (tfrag-trees UNKNOWN 8 :offset-assert 8) +; (tfrag-levels UNKNOWN 8 :offset-assert 40) +; (trans-tfrag-tree-count int32 :offset-assert 72) +; (trans-tfrag-trees UNKNOWN 8 :offset-assert 76) +; (trans-tfrag-levels UNKNOWN 8 :offset-assert 108) +; (dirt-tfrag-tree-count int32 :offset-assert 140) +; (dirt-tfrag-trees UNKNOWN 8 :offset-assert 144) +; (dirt-tfrag-levels UNKNOWN 8 :offset-assert 176) +; (ice-tfrag-tree-count int32 :offset-assert 208) +; (ice-tfrag-trees UNKNOWN 8 :offset-assert 212) +; (ice-tfrag-levels UNKNOWN 8 :offset-assert 244) +; (lowres-tfrag-tree-count int32 :offset-assert 276) +; (lowres-tfrag-trees UNKNOWN 8 :offset-assert 280) +; (lowres-tfrag-levels UNKNOWN 8 :offset-assert 312) +; (lowres-trans-tfrag-tree-count int32 :offset-assert 344) +; (lowres-trans-tfrag-trees UNKNOWN 8 :offset-assert 348) +; (lowres-trans-tfrag-levels UNKNOWN 8 :offset-assert 380) +; (shrub-tree-count int32 :offset-assert 412) +; (shrub-trees UNKNOWN 8 :offset-assert 416) +; (shrub-levels UNKNOWN 8 :offset-assert 448) +; (tie-tree-count int32 :offset-assert 480) +; (tie-trees UNKNOWN 8 :offset-assert 484) +; (tie-levels UNKNOWN 8 :offset-assert 516) +; (tie-generic UNKNOWN 8 :offset-assert 548) +; (wait-to-vu0 uint32 :offset-assert 580) +; ) +; :method-count-assert 9 +; :size-assert #x248 +; :flag-assert #x900000248 +; ) + +; ;; subdivide-h +; (deftype subdivide-settings (basic) +; ((dist UNKNOWN 5 :offset-assert 4) +; (meters UNKNOWN 5 :offset-assert 24) +; (close UNKNOWN 4 :offset-assert 44) +; (far UNKNOWN 4 :offset-assert 60) +; ) +; :method-count-assert 9 +; :size-assert #x4c +; :flag-assert #x90000004c +; ) + +; ;; subdivide-h +; (deftype subdivide-dists (structure) +; ((data UNKNOWN 32 :offset-assert 0) +; (vector UNKNOWN 8 :offset-assert 0) +; (k0s UNKNOWN 4 :offset-assert 0) +; (k1s UNKNOWN 4 :offset-assert 64) +; ) +; :method-count-assert 9 +; :size-assert #x80 +; :flag-assert #x900000080 +; ) + +; ;; subdivide-h +; (deftype gs-packed-rgba (structure) +; ((data UNKNOWN 4 :offset-assert 0) +; (red int32 :offset-assert 0) +; (green int32 :offset-assert 4) +; (blue int32 :offset-assert 8) +; (alpha int32 :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; subdivide-h +; (deftype gs-packed-xyzw (structure) +; ((data UNKNOWN 4 :offset-assert 0) +; (x int32 :offset-assert 0) +; (y int32 :offset-assert 4) +; (z int32 :offset-assert 8) +; (w int32 :offset-assert 12) +; (quad uint128 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; subdivide-h +; (deftype gs-packed-stq (structure) +; ((data UNKNOWN 4 :offset-assert 0) +; (tex-s float :offset-assert 0) +; (tex-t float :offset-assert 4) +; (tex-q float :offset-assert 8) +; (quad uint128 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; subdivide-h +; (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 +; ) + +; ;; subdivide-h +; (deftype gs-packed-gt4 (structure) +; ((data UNKNOWN 4 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #xc0 +; :flag-assert #x9000000c0 +; ) + +; ;; subdivide-h +; (deftype terrain-bsp (structure) +; ((lev-index int32 :offset-assert 0) +; (mood basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; subdivide-h +; (deftype terrain-stats (structure) +; ((pris tr-stat :inline :offset-assert 0) +; (tie-generic tr-stat :inline :offset-assert 16) +; (tie tr-stat :inline :offset-assert 32) +; (tie-near tr-stat :inline :offset-assert 48) +; (shrub-near tr-stat :inline :offset-assert 64) +; (shrub tr-stat :inline :offset-assert 80) +; (tfrag-near tr-stat :inline :offset-assert 96) +; (tfrag tr-stat :inline :offset-assert 112) +; (billboard tr-stat :inline :offset-assert 128) +; (trans-tfrag tr-stat :inline :offset-assert 144) +; (trans-tfrag-near tr-stat :inline :offset-assert 160) +; (trans-pris tr-stat :inline :offset-assert 176) +; (trans-shrub tr-stat :inline :offset-assert 192) +; (ocean-mid tr-stat :inline :offset-assert 208) +; (ocean-near tr-stat :inline :offset-assert 224) +; (total tr-stat :inline :offset-assert 240) +; ) +; :method-count-assert 9 +; :size-assert #x100 +; :flag-assert #x900000100 +; ) + +; ;; subdivide-h +; (deftype dma-area (structure) +; ((draw-node-dma draw-node-dma :inline :offset-assert 0) +; (tfrag-dma tfrag-dma :inline :offset-assert 0) +; (instance-shrub-dma instance-shrub-dma :inline :offset-assert 0) +; (instance-tie-dma instance-tie-dma :inline :offset-assert 0) +; (prototype-tie-dma prototype-tie-dma :inline :offset-assert 0) +; (time-of-day-dma time-of-day-dma :inline :offset-assert 0) +; (decomp-work decomp-work :inline :offset-assert 0) +; (ocean-vertex UNKNOWN 4 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x38a0 +; :flag-assert #x9000038a0 +; ) + +; ;; subdivide-h +; (deftype background-area (structure) +; ((dma-area dma-area :inline :offset-assert 0) +; (vis-list UNKNOWN 2048 :offset-assert 14496) +; ) +; :method-count-assert 9 +; :size-assert #x40a0 +; :flag-assert #x9000040a0 +; ) + +; ;; subdivide-h +; (deftype foreground-area (structure) +; ((joint-work joint-work :inline :offset-assert 0) +; (generic-work generic-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 #x3fd0 +; :flag-assert #x900003fd0 +; ) + +; ;; subdivide-h +; (deftype ambient-area (structure) +; ((ambient-list ambient-list :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x2004 +; :flag-assert #x900002004 +; ) + +; ;; subdivide-h +; (deftype work-area (structure) +; ((background background-area :inline :offset-assert 0) +; (foreground foreground-area :inline :offset-assert 0) +; (ambient ambient-area :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x40a0 +; :flag-assert #x9000040a0 +; ) + +; ;; subdivide-h +; (deftype terrain-context (structure) +; ((bsp terrain-bsp :inline :offset-assert 0) +; (work work-area :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x40b0 +; :flag-assert #x9000040b0 +; ) + +; ;; entity-h +; (deftype entity-perm (structure) +; ((user-object UNKNOWN 2 :offset-assert 0) +; (user-uint64 uint64 :offset-assert 0) +; (user-float UNKNOWN 2 :offset-assert 0) +; (user-int32 UNKNOWN 2 :offset-assert 0) +; (user-uint32 UNKNOWN 2 :offset-assert 0) +; (user-int16 UNKNOWN 4 :offset-assert 0) +; (user-uint16 UNKNOWN 4 :offset-assert 0) +; (user-int8 UNKNOWN 8 :offset-assert 0) +; (user-uint8 UNKNOWN 8 :offset-assert 0) +; (status uint16 :offset-assert 8) +; (dummy UNKNOWN 1 :offset-assert 10) +; (task uint8 :offset-assert 11) +; (aid uint32 :offset-assert 12) +; (quad uint128 :offset-assert 0) +; ) +; :method-count-assert 10 +; :size-assert #x10 +; :flag-assert #xa00000010 +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; entity-h +; (deftype entity-links (structure) +; ((prev-link entity-links :offset-assert 0) +; (next-link entity-links :offset-assert 4) +; (entity basic :offset-assert 8) +; (process basic :offset-assert 12) +; (level basic :offset-assert 16) +; (vis-id int32 :offset-assert 20) +; (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 +; (dummy-9 () none 9) +; ) +; ) + +; ;; entity-h +; (deftype entity-perm-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; entity-h +; (deftype entity-links-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; entity-h +; (deftype entity-ambient-data (structure) +; ((user-object UNKNOWN 3 :offset-assert 0) +; (function basic :offset-assert 12) +; (quad uint128 :offset-assert 0) +; (user-uint64 UNKNOWN 1 :offset-assert 0) +; (user-float UNKNOWN 3 :offset-assert 0) +; (user-int32 UNKNOWN 3 :offset-assert 0) +; (user-uint32 UNKNOWN 3 :offset-assert 0) +; (user-int16 UNKNOWN 6 :offset-assert 0) +; (user-uint16 UNKNOWN 6 :offset-assert 0) +; (user-int8 UNKNOWN 12 :offset-assert 0) +; (user-uint8 UNKNOWN 12 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; entity-h +; (deftype entity-ambient-data-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; entity-h +; (deftype entity-info (basic) +; ((ptype basic :offset-assert 4) +; (package basic :offset-assert 8) +; (art-group basic :offset-assert 12) +; (pool basic :offset-assert 16) +; (heap-size int32 :offset-assert 20) +; ) +; :method-count-assert 9 +; :size-assert #x18 +; :flag-assert #x900000018 +; ) + +; ;; entity-h +; (deftype actor-bank (basic) +; ((pause-dist float :offset-assert 4) +; (birth-dist float :offset-assert 8) +; (birth-max int32 :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; 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 UNKNOWN 1 :offset-assert 0) +; (data64 UNKNOWN 6 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; sprite-h +; (deftype sprite-array-2d (basic) +; ((num-sprites UNKNOWN 2 :offset-assert 4) +; (num-valid UNKNOWN 2 :offset-assert 12) +; (vec-data uint32 :offset-assert 20) +; (adgif-data uint32 :offset-assert 24) +; (pad UNKNOWN 4 :offset-assert 32) +; (data UNKNOWN 1 :offset-assert 96) +; ) +; :method-count-assert 9 +; :size-assert #x70 +; :flag-assert #x900000070 +; ) + +; ;; sprite-h +; (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 UNKNOWN 1 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; sprite-h +; (deftype sprite-array-3d (basic) +; ((num-sprites UNKNOWN 2 :offset-assert 4) +; (num-valid UNKNOWN 2 :offset-assert 12) +; (vec-data uint32 :offset-assert 20) +; (adgif-data uint32 :offset-assert 24) +; (data UNKNOWN 1 :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; shadow-h +; (deftype fake-shadow (structure) +; ((px float :offset-assert 0) +; (py float :offset-assert 4) +; (pz float :offset-assert 8) +; (scale float :offset-assert 12) +; (qx float :offset-assert 16) +; (qy float :offset-assert 20) +; (qz float :offset-assert 24) +; (flags int32 :offset-assert 28) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; shadow-h +; (deftype fake-shadow-buffer (basic) +; ((num-shadows int32 :offset-assert 4) +; (data UNKNOWN 32 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #x408 +; :flag-assert #x900000408 +; ) + +; ;; eye-h +; (deftype eye (structure) +; ((data UNKNOWN 2 :offset-assert 0) +; (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) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; eye-h +; (deftype eye-control (structure) +; ((process uint64 :offset-assert 0) +; (random-time uint16 :offset-assert 8) +; (level uint16 :offset-assert 10) +; (blink float :offset-assert 12) +; (shaders uint32 :offset-assert 16) +; (left eye :inline :offset-assert 32) +; (right eye :inline :offset-assert 64) +; ) +; :method-count-assert 9 +; :size-assert #x60 +; :flag-assert #x900000060 +; ) + +; ;; eye-h +; (deftype eye-control-array (basic) +; ((data UNKNOWN 11 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x430 +; :flag-assert #x900000430 +; ) + +; ;; eye-h +; (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 UNKNOWN 10 :offset-assert 96) +; ) +; :method-count-assert 9 +; :size-assert #x88 +; :flag-assert #x900000088 +; ) + +; ;; sparticle-launcher-h +; (deftype sp-field-init-spec (structure) +; ((field uint16 :offset-assert 0) +; (flags uint16 :offset-assert 2) +; (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 basic :offset-assert 4) +; (tex uint32 :offset-assert 4) +; (pntr uint32 :offset-assert 4) +; (sym basic :offset-assert 4) +; (sound basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; sparticle-launcher-h +; (deftype sparticle-launcher (basic) +; ((birthaccum float :offset-assert 4) +; (soundaccum float :offset-assert 8) +; (init-specs uint32 :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; sparticle-launcher-h +; (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) +; (period uint16 :offset-assert 14) +; (length uint16 :offset-assert 16) +; (offset uint16 :offset-assert 18) +; (hour-mask uint32 :offset-assert 20) +; (binding uint32 :offset-assert 24) +; ) +; :method-count-assert 9 +; :size-assert #x1c +; :flag-assert #x90000001c +; ) + +; ;; sparticle-launcher-h +; (deftype sparticle-launch-state (structure) +; ((group-item sparticle-group-item :offset-assert 0) +; (flags uint16 :offset-assert 4) +; (randomize uint16 :offset-assert 6) +; (origin vector :offset-assert 8) +; (sprite3d sprite-vec-data-3d :offset-assert 12) +; (sprite basic :offset-assert 16) +; (offset uint32 :offset-assert 20) +; (accum float :offset-assert 24) +; (spawn-time uint32 :offset-assert 28) +; (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 #x20 +; :flag-assert #x900000020 +; ) + +; ;; sparticle-launcher-h +; (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) +; (name basic :offset-assert 12) +; (launcher uint32 :offset-assert 16) +; (bounds sphere :inline :offset-assert 32) +; ) +; :method-count-assert 10 +; :size-assert #x30 +; :flag-assert #xa00000030 +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; sparticle-launcher-h +; (deftype sparticle-launch-control (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (group basic :offset-assert 16) +; (proc basic :offset-assert 20) +; (local-clock int32 :offset-assert 24) +; (fade float :offset-assert 28) +; (matrix int32 :offset-assert 32) +; (last-spawn-frame int32 :offset-assert 36) +; (last-spawn-time int32 :offset-assert 40) +; (center vector :inline :offset-assert 48) +; (data UNKNOWN :dynamic :offset-assert 64) +; ) +; :method-count-assert 14 +; :size-assert #x40 +; :flag-assert #xe00000040 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; 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) +; (accel vector3s :inline :offset-assert 64) +; (scalevelx float :offset-assert 28) +; (scalevely float :offset-assert 44) +; (friction float :offset-assert 96) +; (timer int32 :offset-assert 100) +; (flags uint32 :offset-assert 104) +; (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-sprite sprite-vec-data-2d :offset-assert 108) +; (func basic :offset-assert 112) +; (next-time uint32 :offset-assert 116) +; (next-launcher basic :offset-assert 120) +; (cache-alpha float :offset-assert 124) +; (valid basic :offset-assert 128) +; (key basic :offset-assert 132) +; (binding sparticle-launch-state :offset-assert 136) +; (data UNKNOWN 1 :offset-assert 12) +; (dataf UNKNOWN 1 :offset-assert 12) +; (datac UNKNOWN 1 :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #x8c +; :flag-assert #x90000008c +; ;; field key is a basic loaded with a signed load +; ) + +; ;; sparticle-h +; (deftype sparticle-launchinfo (structure) +; ((launchrot vector :inline :offset-assert 0) +; (conerot vector :inline :offset-assert 16) +; (coneradius float :offset-assert 32) +; (rotate-y float :offset-assert 36) +; (data UNKNOWN 1 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x28 +; :flag-assert #x900000028 +; ) + +; ;; sparticle-h +; (deftype sparticle-system (basic) +; ((blocks UNKNOWN 2 :offset-assert 4) +; (length UNKNOWN 2 :offset-assert 12) +; (num-alloc UNKNOWN 2 :offset-assert 20) +; (is-3d basic :offset-assert 28) +; (flags uint32 :offset-assert 32) +; (alloc-table uint32 :offset-assert 36) +; (cpuinfo-table uint32 :offset-assert 40) +; (vecdata-table uint32 :offset-assert 44) +; (adgifdata-table uint32 :offset-assert 48) +; ) +; :method-count-assert 9 +; :size-assert #x34 +; :flag-assert #x900000034 +; ) + +; ;; actor-link-h +; (deftype actor-link-info (basic) +; ((process basic :offset-assert 4) +; (next basic :offset-assert 8) +; (prev basic :offset-assert 12) +; ) +; :method-count-assert 26 +; :size-assert #x10 +; :flag-assert #x1a00000010 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; ) +; ) + +; ;; camera-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) +; (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) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; camera-h +; (deftype cam-index (structure) +; ((flags uint32 :offset-assert 0) +; (vec UNKNOWN 2 :offset-assert 16) +; ) +; :method-count-assert 11 +; :size-assert #x30 +; :flag-assert #xb00000030 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; camera-h +; (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 +; ) + +; ;; camera-h +; (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 +; ) + +; ;; camera-h +; (deftype tracking-spline (structure) +; ((point UNKNOWN 32 :offset-assert 0) +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +; ;; camera-h +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; camera-h +; (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 +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; camera-h +; (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) +; (use-point-of-interest basic :offset-assert 140) +; (point-of-interest vector :inline :offset-assert 144) +; (point-of-interest-blend cam-float-seeker :inline :offset-assert 160) +; (underwater-blend cam-float-seeker :inline :offset-assert 184) +; ) +; :method-count-assert 9 +; :size-assert #xd0 +; :flag-assert #x9000000d0 +; ) + +; ;; camera-h +; (deftype camera-combiner (process) +; ((~Ttrans vector :inline :offset-assert 112) +; (~Tinv-camera-rot matrix :inline :offset-assert 128) +; (~Tfov float :offset-assert 192) +; (~Tinterp-val float :offset-assert 196) +; (~Tinterp-step float :offset-assert 200) +; (~Tdist-from-src float :offset-assert 204) +; (~Tdist-from-dest float :offset-assert 208) +; (~Tflip-control-axis vector :inline :offset-assert 224) +; (~Tvelocity vector :inline :offset-assert 240) +; (~Ttracking-status uint64 :offset-assert 256) +; (~Ttracking-options int32 :offset-assert 264) +; (~Ttracking cam-rotation-tracker :inline :offset-assert 272) +; ) +; :method-count-assert 14 +; :size-assert #x1e0 +; :flag-assert #xe017001e0 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; camera-h +; (deftype camera-slave (process) +; ((~Ttrans vector :inline :offset-assert 112) +; (~Tfov float :offset-assert 128) +; (~Tfov0 float :offset-assert 132) +; (~Tfov1 float :offset-assert 136) +; (~Tfov-index cam-index :inline :offset-assert 144) +; (~Ttracking cam-rotation-tracker :inline :offset-assert 192) +; (~Tview-off-param float :offset-assert 400) +; (~Tview-off vector :inline :offset-assert 416) +; (~Tmin-z-override float :offset-assert 432) +; (~Tview-flat vector :inline :offset-assert 448) +; (~Tstring-vel-dir uint32 :offset-assert 464) +; (~Tstring-trans vector :inline :offset-assert 480) +; (~Tposition-spline tracking-spline :inline :offset-assert 496) +; (~Tpivot-pt vector :inline :offset-assert 2144) +; (~Tpivot-rad float :offset-assert 2160) +; (~Tcircular-follow vector :inline :offset-assert 2176) +; (~Tmax-angle-offset float :offset-assert 2192) +; (~Tmax-angle-curr float :offset-assert 2196) +; (~Toptions uint32 :offset-assert 2200) +; (~Tcam-entity basic :offset-assert 2204) +; (~Tvelocity vector :inline :offset-assert 2208) +; (~Tdesired-pos vector :inline :offset-assert 2224) +; (~Ttime-dist-too-far uint32 :offset-assert 2240) +; (~Tlos-state uint32 :offset-assert 2244) +; (~Tgood-point vector :inline :offset-assert 2256) +; (~Tlos-tgt-spline-pt int32 :offset-assert 2272) +; (~Tlos-tgt-spline-pt-incarnation int32 :offset-assert 2276) +; (~Tlos-last-pos vector :inline :offset-assert 2288) +; (~Tintro-curve curve :inline :offset-assert 2304) +; (~Tintro-offset vector :inline :offset-assert 2336) +; (~Tintro-t float :offset-assert 2352) +; (~Tintro-t-step float :offset-assert 2356) +; (~Toutro-exit-value float :offset-assert 2360) +; (~Tspline-exists basic :offset-assert 2364) +; (~Tspline-curve curve :inline :offset-assert 2368) +; (~Tspline-offset vector :inline :offset-assert 2400) +; (~Tindex cam-index :inline :offset-assert 2416) +; (~Tsaved-pt vector :inline :offset-assert 2464) +; (~Tspline-tt float :offset-assert 2480) +; (~Tspline-follow-dist float :offset-assert 2484) +; (~Tchange-event-from uint32 :offset-assert 2488) +; (~Tenter-has-run basic :offset-assert 2492) +; (~Tblend-from-type uint64 :offset-assert 2496) +; (~Tblend-to-type uint64 :offset-assert 2504) +; (~Thave-phony-joystick basic :offset-assert 2512) +; (~Tphony-joystick-x float :offset-assert 2516) +; (~Tphony-joystick-y float :offset-assert 2520) +; (~Tstring-min-val vector :inline :offset-assert 2528) +; (~Tstring-max-val vector :inline :offset-assert 2544) +; (~Tstring-val-locked basic :offset-assert 2560) +; ) +; :method-count-assert 14 +; :size-assert #xa04 +; :flag-assert #xe09a00a04 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; camera-h +; (deftype camera-master (process) +; ((~Tmaster-options uint32 :offset-assert 112) +; (~Tnum-slaves int32 :offset-assert 116) +; (~Tslave UNKNOWN 2 :offset-assert 120) +; (~Tslave-options uint32 :offset-assert 128) +; (~Tview-off-param-save float :offset-assert 132) +; (~Tchanger uint32 :offset-assert 136) +; (~Tcam-entity basic :offset-assert 140) +; (~TstringMinLength float :offset-assert 144) +; (~TstringMaxLength float :offset-assert 148) +; (~TstringMinHeight float :offset-assert 152) +; (~TstringMaxHeight float :offset-assert 156) +; (~Tstring-min cam-vector-seeker :inline :offset-assert 160) +; (~Tstring-max cam-vector-seeker :inline :offset-assert 224) +; (~Tstring-push-z float :offset-assert 284) +; (~TstringCliffHeight float :offset-assert 288) +; (~Tno-intro uint32 :offset-assert 292) +; (~Tforce-blend uint32 :offset-assert 296) +; (~Tforce-blend-time uint32 :offset-assert 300) +; (~Tlocal-down vector :inline :offset-assert 304) +; (~Tdrawable-target uint64 :offset-assert 320) +; (~Twhich-bone int32 :offset-assert 328) +; (~Tpov-handle uint64 :offset-assert 336) +; (~Tpov-bone int32 :offset-assert 344) +; (~Tbeing-attacked basic :offset-assert 348) +; (~Tattack-start uint64 :offset-assert 352) +; (~Ton-ground basic :offset-assert 360) +; (~Tunder-water int32 :offset-assert 364) +; (~Ton-pole basic :offset-assert 368) +; (~Ttgt-rot-mat matrix :inline :offset-assert 384) +; (~Ttgt-face-mat matrix :inline :offset-assert 448) +; (~Ttpos-old vector :inline :offset-assert 512) +; (~Ttpos-curr vector :inline :offset-assert 528) +; (~Ttarget-height float :offset-assert 544) +; (~Ttpos-old-adj vector :inline :offset-assert 560) +; (~Ttpos-curr-adj vector :inline :offset-assert 576) +; (~Ttpos-tgt vector :inline :offset-assert 592) +; (~Tupspeed float :offset-assert 608) +; (~Tpitch-off vector :inline :offset-assert 624) +; (~Tfoot-offset float :offset-assert 640) +; (~Thead-offset float :offset-assert 644) +; (~Ttarget-spline tracking-spline :inline :offset-assert 656) +; (~Tease-from vector :inline :offset-assert 2304) +; (~Tease-t float :offset-assert 2320) +; (~Tease-step float :offset-assert 2324) +; (~Tease-to vector :inline :offset-assert 2336) +; (~Toutro-curve curve :inline :offset-assert 2352) +; (~Toutro-t float :offset-assert 2372) +; (~Toutro-t-step float :offset-assert 2376) +; (~Toutro-exit-value float :offset-assert 2380) +; (~Twater-drip-time uint64 :offset-assert 2384) +; (~Twater-drip basic :offset-assert 2392) +; (~Twater-drip-mult float :offset-assert 2396) +; (~Twater-drip-speed float :offset-assert 2400) +; ) +; :method-count-assert 14 +; :size-assert #x964 +; :flag-assert #xe09000964 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; assert-h +; (deftype __assert-info-private-struct (structure) +; ((filename basic :offset-assert 0) +; (line-num uint16 :offset-assert 4) +; (column-num uint16 :offset-assert 6) +; ) +; :method-count-assert 11 +; :size-assert #x8 +; :flag-assert #xb00000008 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; hud-h +; (deftype hud-icon (basic) +; ((icon uint32 :offset-assert 4) +; (icon-y int32 :offset-assert 8) +; (icon-x int32 :offset-assert 12) +; (icon-z int32 :offset-assert 16) +; (scale-x float :offset-assert 20) +; (scale-y float :offset-assert 24) +; ) +; :method-count-assert 9 +; :size-assert #x1c +; :flag-assert #x90000001c +; ) + +; ;; hud-h +; (deftype hud-particle (basic) +; ((part basic :offset-assert 4) +; (init-pos vector :inline :offset-assert 16) +; (pos vector :inline :offset-assert 32) +; (prev-pos vector :inline :offset-assert 48) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; hud-h +; (deftype hud (process) +; ((~Tvalue int32 :offset-assert 112) +; (~Tvalue2 int32 :offset-assert 116) +; (~Ttarget-value int32 :offset-assert 120) +; (~Tlast-increment-time uint64 :offset-assert 128) +; (~Tlast-target-equal-time uint64 :offset-assert 136) +; (~Toffset int32 :offset-assert 144) +; (~Ty-offset int32 :offset-assert 148) +; (~Tnext-y-offset int32 :offset-assert 152) +; (~Tx-sgn int32 :offset-assert 156) +; (~Ty-sgn int32 :offset-assert 160) +; (~Ttext-x int32 :offset-assert 164) +; (~Ttext-y int32 :offset-assert 168) +; (~Tfriend int32 :offset-assert 172) +; (~Tfirst-init basic :offset-assert 176) +; (~Tincrement-on-event basic :offset-assert 180) +; (~Tskip-particle int32 :offset-assert 184) +; (~Tdisable basic :offset-assert 188) +; (~Tforce-on-screen basic :offset-assert 192) +; (~Tdeactivate-when-hidden basic :offset-assert 196) +; (~Ttrigger-time uint64 :offset-assert 200) +; (~Tlast-hide-time uint64 :offset-assert 208) +; (~Tnb-of-icons int32 :offset-assert 216) +; (~Ticons UNKNOWN 6 :offset-assert 220) +; (~Tmax-nb-of-particles int32 :offset-assert 244) +; (~Tnb-of-particles int32 :offset-assert 248) +; (~Tparticles UNKNOWN 7 :offset-assert 252) +; ) +; :method-count-assert 27 +; :size-assert #x118 +; :flag-assert #x1b00b00118 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; hud-h +; (deftype hud-parts (structure) +; ((data UNKNOWN 9 :offset-assert 0) +; (pickups uint32 :offset-assert 0) +; (money uint32 :offset-assert 4) +; (fuel-cell uint32 :offset-assert 8) +; (health uint32 :offset-assert 12) +; (buzzers uint32 :offset-assert 16) +; (power uint32 :offset-assert 20) +; (bike-speed uint32 :offset-assert 24) +; (bike-heat uint32 :offset-assert 28) +; (money-all uint32 :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x24 +; :flag-assert #x900000024 +; ) + +; ;; progress-h +; (deftype count-info (structure) +; ((money-count int32 :offset-assert 0) +; (buzzer-count int32 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; progress-h +; (deftype game-count-info (basic) +; ((length int32 :offset-assert 4) +; (data UNKNOWN :dynamic :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; progress-h +; (deftype task-info-data (basic) +; ((task-id uint8 :offset-assert 4) +; (task-name UNKNOWN 4 :offset-assert 8) +; (text-index-when-resolved int32 :offset-assert 24) +; ) +; :method-count-assert 9 +; :size-assert #x1c +; :flag-assert #x90000001c +; ) + +; ;; progress-h +; (deftype level-tasks-info (basic) +; ((level-name-id uint32 :offset-assert 4) +; (text-group-index int32 :offset-assert 8) +; (nb-of-tasks int32 :offset-assert 12) +; (buzzer-task-index int32 :offset-assert 16) +; (task-info UNKNOWN 8 :offset-assert 20) +; ) +; :method-count-assert 9 +; :size-assert #x34 +; :flag-assert #x900000034 +; ) + +; ;; progress-h +; (deftype game-option (basic) +; ((option-type uint64 :offset-assert 8) +; (name uint32 :offset-assert 16) +; (scale basic :offset-assert 20) +; (param1 float :offset-assert 24) +; (param2 float :offset-assert 28) +; (param3 int32 :offset-assert 32) +; (value-to-modify uint32 :offset-assert 36) +; ) +; :method-count-assert 9 +; :size-assert #x28 +; :flag-assert #x900000028 +; ) + +; ;; progress-h +; (deftype progress (process) +; ((~Tcurrent-debug-string int32 :offset-assert 112) +; (~Tcurrent-debug-language int32 :offset-assert 116) +; (~Tcurrent-debug-group int32 :offset-assert 120) +; (~Tin-out-position int32 :offset-assert 124) +; (~Tdisplay-state uint64 :offset-assert 128) +; (~Tnext-display-state uint64 :offset-assert 136) +; (~Toption-index int32 :offset-assert 144) +; (~Tselected-option basic :offset-assert 148) +; (~Tcompletion-percentage float :offset-assert 152) +; (~Tready-to-run basic :offset-assert 156) +; (~Tdisplay-level-index int32 :offset-assert 160) +; (~Tnext-level-index int32 :offset-assert 164) +; (~Ttask-index int32 :offset-assert 168) +; (~Tin-transition basic :offset-assert 172) +; (~Tlast-in-transition basic :offset-assert 176) +; (~Tforce-transition basic :offset-assert 180) +; (~Tstat-transition basic :offset-assert 184) +; (~Tlevel-transition int32 :offset-assert 188) +; (~Tlanguage-selection uint64 :offset-assert 192) +; (~Tlanguage-direction basic :offset-assert 200) +; (~Tlanguage-transition basic :offset-assert 204) +; (~Tlanguage-x-offset int32 :offset-assert 208) +; (~Tsides-x-scale float :offset-assert 212) +; (~Tsides-y-scale float :offset-assert 216) +; (~Tleft-x-offset int32 :offset-assert 220) +; (~Tright-x-offset int32 :offset-assert 224) +; (~Tbutton-scale float :offset-assert 228) +; (~Tslot-scale float :offset-assert 232) +; (~Tleft-side-x-scale float :offset-assert 236) +; (~Tleft-side-y-scale float :offset-assert 240) +; (~Tright-side-x-scale float :offset-assert 244) +; (~Tright-side-y-scale float :offset-assert 248) +; (~Tsmall-orb-y-offset int32 :offset-assert 252) +; (~Tbig-orb-y-offset int32 :offset-assert 256) +; (~Ttransition-offset int32 :offset-assert 260) +; (~Ttransition-offset-invert int32 :offset-assert 264) +; (~Ttransition-percentage float :offset-assert 268) +; (~Ttransition-percentage-invert float :offset-assert 272) +; (~Ttransition-speed float :offset-assert 276) +; (~Ttotal-nb-of-power-cells int32 :offset-assert 280) +; (~Ttotal-nb-of-orbs int32 :offset-assert 284) +; (~Ttotal-nb-of-buzzers int32 :offset-assert 288) +; (~Tcard-info mc-slot-info :offset-assert 292) +; (~Tlast-option-index-change uint64 :offset-assert 296) +; (~Tvideo-mode-timeout uint64 :offset-assert 304) +; (~Tdisplay-state-stack UNKNOWN 5 :offset-assert 312) +; (~Toption-index-stack UNKNOWN 5 :offset-assert 352) +; (~Tdisplay-state-pos int32 :offset-assert 372) +; (~Tnb-of-icons int32 :offset-assert 376) +; (~Ticons UNKNOWN 6 :offset-assert 380) +; (~Tmax-nb-of-particles int32 :offset-assert 404) +; (~Tnb-of-particles int32 :offset-assert 408) +; (~Tparticles UNKNOWN 40 :offset-assert 412) +; (~Tparticle-state UNKNOWN 40 :offset-assert 572) +; ) +; :method-count-assert 59 +; :size-assert #x2dc +; :flag-assert #x3b027002dc +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; ) +; ) + +; ;; 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 uint32 :offset-assert 20) +; (data UNKNOWN :dynamic :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; rpc-h +; (deftype rpc-buffer-pair (basic) +; ((buffer UNKNOWN 2 :offset-assert 4) +; (current basic :offset-assert 12) +; (last-recv-buffer uint32 :offset-assert 16) +; (rpc-port int32 :offset-assert 20) +; ) +; :method-count-assert 15 +; :size-assert #x18 +; :flag-assert #xf00000018 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; path-h +; (deftype path-control (basic) +; ((flags uint32 :offset-assert 4) +; (name basic :offset-assert 8) +; (process basic :offset-assert 12) +; (curve curve :inline :offset-assert 16) +; (num-cverts int32 :offset-assert 20) +; (cverts uint32 :offset-assert 16) +; ) +; :method-count-assert 21 +; :size-assert #x24 +; :flag-assert #x1500000024 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; path-h +; (deftype curve-control (path-control) +; ((flags uint32 :offset-assert 4) +; (name basic :offset-assert 8) +; (process basic :offset-assert 12) +; (curve curve :inline :offset-assert 16) +; (num-cverts int32 :offset-assert 20) +; (cverts uint32 :offset-assert 16) +; ) +; :method-count-assert 21 +; :size-assert #x24 +; :flag-assert #x1500000024 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; navigate-h +; (deftype nav-poly (structure) +; ((id uint8 :offset-assert 0) +; (vertex UNKNOWN 3 :offset-assert 1) +; (adj-poly UNKNOWN 3 :offset-assert 4) +; (pat uint8 :offset-assert 7) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; navigate-h +; (deftype nav-vertex (vector) +; ((data UNKNOWN 4 :offset-assert 0) +; (x float :offset-assert 0) +; (y float :offset-assert 4) +; (z float :offset-assert 8) +; (w float :offset-assert 12) +; (quad uint128 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; navigate-h +; (deftype nav-sphere (structure) +; ((trans sphere :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; navigate-h +; (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) +; (terminated basic :offset-assert 64) +; (reached-dest basic :offset-assert 68) +; (hit-boundary basic :offset-assert 72) +; (hit-gap basic :offset-assert 76) +; ) +; :method-count-assert 9 +; :size-assert #x50 +; :flag-assert #x900000050 +; ) + +; ;; navigate-h +; (deftype nav-route-portal (structure) +; ((next-poly nav-poly :offset-assert 0) +; (vertex UNKNOWN 2 :offset-assert 4) +; (edge-index int8 :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #xd +; :flag-assert #x90000000d +; ) + +; ;; navigate-h +; (deftype clip-travel-vector-to-mesh-return-info (structure) +; ((found-boundary basic :offset-assert 0) +; (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 int32 :offset-assert 88) +; (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 +; ) + +; ;; navigate-h +; (deftype nav-node (structure) +; ((center-x float :offset-assert 0) +; (center-y float :offset-assert 4) +; (center-z float :offset-assert 8) +; (type uint16 :offset-assert 12) +; (parent-offset uint16 :offset-assert 14) +; (center vector :inline :offset-assert 0) +; (radius-x float :offset-assert 16) +; (radius-y float :offset-assert 20) +; (radius-z float :offset-assert 24) +; (left-offset uint16 :offset-assert 28) +; (right-offset uint16 :offset-assert 30) +; (num-tris uint32 :offset-assert 28) +; (radius vector :inline :offset-assert 16) +; (scale-x float :offset-assert 32) +; (first-tris UNKNOWN 4 :offset-assert 36) +; (scale-z float :offset-assert 40) +; (last-tris UNKNOWN 4 :offset-assert 44) +; (scale vector :inline :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; navigate-h +; (deftype nav-lookup-elem (structure) +; ((vec vector :inline :offset-assert 0) +; (y-thresh float :offset-assert 12) +; (time uint32 :offset-assert 16) +; (node-offset uint32 :offset-assert 20) +; (lookup-type uint8 :offset-assert 24) +; (poly-ind uint8 :offset-assert 25) +; (dummy0 uint16 :offset-assert 26) +; (dummy uint32 :offset-assert 28) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; navigate-h +; (deftype nav-mesh (basic) +; ((user-list basic :offset-assert 4) +; (poly-lookup-history UNKNOWN 2 :offset-assert 8) +; (debug-time uint8 :offset-assert 10) +; (static-sphere-count uint8 :offset-assert 11) +; (static-sphere uint32 :offset-assert 12) +; (bounds sphere :inline :offset-assert 16) +; (origin vector :inline :offset-assert 32) +; (cache UNKNOWN 4 :offset-assert 48) +; (node-count int32 :offset-assert 176) +; (nodes uint32 :offset-assert 180) +; (vertex-count int32 :offset-assert 184) +; (vertex uint32 :offset-assert 188) +; (poly-count int32 :offset-assert 192) +; (poly uint32 :offset-assert 196) +; (route uint32 :offset-assert 200) +; ) +; :method-count-assert 30 +; :size-assert #xcc +; :flag-assert #x1e000000cc +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; navigate-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 +; ) + +; ;; navigate-h +; (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 +; ) + +; ;; navigate-h +; (deftype nav-control (basic) +; ((flags uint32 :offset-assert 4) +; (process basic :offset-assert 8) +; (shape basic :offset-assert 12) +; (mesh basic :offset-assert 16) +; (gap-event basic :offset-assert 20) +; (block-event basic :offset-assert 24) +; (current-poly nav-poly :offset-assert 28) +; (next-poly nav-poly :offset-assert 32) +; (target-poly nav-poly :offset-assert 36) +; (portal UNKNOWN 2 :offset-assert 40) +; (nearest-y-threshold meters :offset-assert 48) +; (event-temp vector :inline :offset-assert 64) +; (old-travel vector :inline :offset-assert 80) +; (blocked-travel vector :inline :offset-assert 96) +; (prev-pos vector :inline :offset-assert 112) +; (extra-nav-sphere vector :inline :offset-assert 128) +; (travel vector :inline :offset-assert 144) +; (target-pos vector :inline :offset-assert 160) +; (destination-pos vector :inline :offset-assert 176) +; (block-time uint64 :offset-assert 192) +; (block-count float :offset-assert 200) +; (user-poly nav-poly :offset-assert 204) +; (nav-cull-radius float :offset-assert 208) +; (num-spheres int16 :offset-assert 212) +; (max-spheres int16 :offset-assert 214) +; (sphere UNKNOWN :dynamic :offset-assert 224) +; ) +; :method-count-assert 36 +; :size-assert #xe0 +; :flag-assert #x24000000e0 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; ) +; ) + +; ;; load-dgo +; (deftype load-dgo-msg (structure) +; ((rsvd uint16 :offset-assert 0) +; (result uint16 :offset-assert 2) +; (b1 uint32 :offset-assert 4) +; (b2 uint32 :offset-assert 8) +; (bt uint32 :offset-assert 12) +; (name uint128 :offset-assert 16) +; (address uint32 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; load-dgo +; (deftype load-chunk-msg (structure) +; ((rsvd uint16 :offset-assert 0) +; (result uint16 :offset-assert 2) +; (address uint32 :offset-assert 4) +; (section uint32 :offset-assert 8) +; (maxlen uint32 :offset-assert 12) +; (id uint32 :offset-assert 4) +; (basename UNKNOWN 48 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; load-dgo +; (deftype dgo-header (structure) +; ((length uint32 :offset-assert 0) +; (rootname UNKNOWN 60 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; ramdisk +; (deftype ramdisk-rpc-fill (structure) +; ((rsvd1 int32 :offset-assert 0) +; (ee-id int32 :offset-assert 4) +; (rsvd2 UNKNOWN 2 :offset-assert 8) +; (filename uint128 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; ramdisk +; (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 +; ) + +; ;; ramdisk +; (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 +; ) + +; ;; gsound +; (deftype sound-iop-info (basic) +; ((frame uint32 :offset-assert 16) +; (strpos int32 :offset-assert 20) +; (str-id uint32 :offset-assert 24) +; (str-id-sign int32 :offset-assert 24) +; (freemem uint32 :offset-assert 28) +; (chinfo UNKNOWN 48 :offset-assert 32) +; (freemem2 uint32 :offset-assert 80) +; (nocd uint32 :offset-assert 84) +; (dirtycd uint32 :offset-assert 88) +; (diskspeed UNKNOWN 2 :offset-assert 92) +; (lastspeed uint32 :offset-assert 100) +; (dupseg int32 :offset-assert 104) +; (times UNKNOWN 41 :offset-assert 108) +; (times-seq uint32 :offset-assert 272) +; ) +; :method-count-assert 9 +; :size-assert #x114 +; :flag-assert #x900000114 +; ) + +; ;; gsound +; (deftype flava-table-row (structure) +; ((music basic :offset-assert 0) +; (flava UNKNOWN 50 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x36 +; :flag-assert #x900000036 +; ) + +; ;; gsound +; (deftype flava-table (basic) +; ((row UNKNOWN 20 :offset-assert 4) +; (count int32 :offset-assert 1284) +; ) +; :method-count-assert 9 +; :size-assert #x508 +; :flag-assert #x900000508 +; ) + +; ;; joint +; (deftype joint-anim-matrix (joint-anim) +; () +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; joint +; (deftype joint-anim-transformq (joint-anim) +; () +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ;; too many basic blocks +; ) + +; ;; joint +; (deftype art-joint-anim (art-element) +; () +; :method-count-assert 13 +; :size-assert #x30 +; :flag-assert #xd00000030 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; joint +; (deftype art-group (art) +; () +; :method-count-assert 15 +; :size-assert #x20 +; :flag-assert #xf00000020 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; cylinder +; (deftype cylinder-verts (structure) +; ((vert UNKNOWN 24 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x180 +; :flag-assert #x900000180 +; ) + +; ;; cylinder +; (deftype cylinder-flat-verts (structure) +; ((vert UNKNOWN 10 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #xa0 +; :flag-assert #x9000000a0 +; ) + +; ;; sprite +; (deftype sprite-header (structure) +; ((header UNKNOWN 1 :offset-assert 0) +; (num-sprites int32 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; sprite +; (deftype sprite-hvdf-data (structure) +; ((data UNKNOWN 76 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x4c0 +; :flag-assert #x9000004c0 +; ) + +; ;; sprite +; (deftype sprite-hvdf-control (structure) +; ((alloc UNKNOWN 76 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x4c +; :flag-assert #x90000004c +; ) + +; ;; sprite +; (deftype sprite-aux-list (basic) +; ((num-entries int32 :offset-assert 4) +; (entry int32 :offset-assert 8) +; (data UNKNOWN 1 :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; sprite +; (deftype sprite-aux-list (basic) +; () +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ;; too many basic blocks +; ) + +; ;; sprite +; (deftype sprite-frame-data (structure) +; ((data UNKNOWN 41 :offset-assert 0) +; (cdata UNKNOWN 16 :offset-assert 0) +; (fdata UNKNOWN 25 :offset-assert 256) +; (xy-array UNKNOWN 8 :offset-assert 0) +; (st-array UNKNOWN 4 :offset-assert 128) +; (xyz-array UNKNOWN 4 :offset-assert 192) +; (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) +; (sprite-2d-giftag qword :inline :offset-assert 304) +; (sprite-2d-giftag-2 qword :inline :offset-assert 320) +; (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) +; (screen-shader adgif-shader :inline :offset-assert 464) +; (clipped-giftag qword :inline :offset-assert 544) +; (inv-hmge-scale vector :inline :offset-assert 560) +; (stq-offset vector :inline :offset-assert 576) +; (stq-scale vector :inline :offset-assert 592) +; (rgba-plain qword :inline :offset-assert 608) +; (warp-giftag qword :inline :offset-assert 624) +; (fog-clamp vector :inline :offset-assert 640) +; (fog-min float :offset-assert 640) +; (fog-max float :offset-assert 644) +; (max-scale float :offset-assert 648) +; ) +; :method-count-assert 9 +; :size-assert #x290 +; :flag-assert #x900000290 +; ) + +; ;; sprite-distort +; (deftype sprite-distorter-sine-tables (basic) +; ((aspx float :offset-assert 4) +; (aspy float :offset-assert 8) +; (entry UNKNOWN 128 :offset-assert 16) +; (ientry UNKNOWN 9 :offset-assert 2064) +; (giftag qword :inline :offset-assert 2208) +; (color qword :inline :offset-assert 2224) +; ) +; :method-count-assert 9 +; :size-assert #x8c0 +; :flag-assert #x9000008c0 +; ) + +; ;; debug-sphere +; (deftype debug-sphere-table (basic) +; ((point UNKNOWN 300 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x12d0 +; :flag-assert #x9000012d0 +; ) + +; ;; debug +; (deftype debug-line (structure) +; ((flags int32 :offset-assert 0) +; (bucket int32 :offset-assert 4) +; (v1 vector :inline :offset-assert 16) +; (v2 vector :inline :offset-assert 32) +; (color uint32 :offset-assert 48) +; (mode basic :offset-assert 52) +; (color2 uint32 :offset-assert 56) +; ) +; :method-count-assert 9 +; :size-assert #x3c +; :flag-assert #x90000003c +; ) + +; ;; debug +; (deftype debug-text-3d (structure) +; ((flags int32 :offset-assert 0) +; (bucket int32 :offset-assert 4) +; (pos vector :inline :offset-assert 16) +; (color uint64 :offset-assert 32) +; (offset vector2h :inline :offset-assert 40) +; (str basic :offset-assert 44) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; debug +; (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 +; (deftype debug-vertex-stats (basic) +; () +; :method-count-assert 9 +; :size-assert #x4b10 +; :flag-assert #x900004b10 +; ;; too many basic blocks +; ) + +; ;; 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 +; ) + +; ;; merc-blend-shape +; (deftype blerc-block (structure) +; ((output UNKNOWN 848 :offset-assert 0) +; (header blerc-block-header :inline :offset-assert 848) +; ) +; :method-count-assert 9 +; :size-assert #x370 +; :flag-assert #x900000370 +; ) + +; ;; merc-blend-shape +; (deftype blerc-dcache (structure) +; ((repl-mult UNKNOWN 40 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x280 +; :flag-assert #x900000280 +; ) + +; ;; merc-blend-shape +; (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 +; ) + +; ;; merc-blend-shape +; (deftype blerc-context (structure) +; ((block-a blerc-block :inline :offset-assert 0) +; (dummy UNKNOWN 7312 :offset-assert 880) +; (block-b blerc-block :inline :offset-assert 8192) +; ) +; :method-count-assert 9 +; :size-assert #x2370 +; :flag-assert #x900002370 +; ) + +; ;; merc +; (deftype merc-fragment-control (structure) +; () +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ;; too many basic blocks +; ) + +; ;; merc +; (deftype merc-ctrl (art-element) +; () +; :method-count-assert 13 +; :size-assert #x70 +; :flag-assert #xd00000070 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; ripple +; (deftype ripple-request (structure) +; ((waveform basic :offset-assert 0) +; (effect merc-effect :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; ripple +; (deftype ripple-globals (structure) +; ((count int32 :offset-assert 0) +; (requests UNKNOWN 16 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x84 +; :flag-assert #x900000084 +; ) + +; ;; bones +; (deftype bone-calculation (structure) +; ((flags uint16 :offset-assert 0) +; (num-bones uint16 :offset-assert 2) +; (matrix-area uint32 :offset-assert 4) +; (joints uint32 :offset-assert 8) +; (bones uint32 :offset-assert 12) +; (ripple-scale float :offset-assert 16) +; (ripple-y-scale float :offset-assert 20) +; (ripple-normal-scale float :offset-assert 24) +; (ripple-area uint32 :offset-assert 28) +; (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 +; ) + +; ;; bones +; (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 +; ) + +; ;; bones +; (deftype texscroll-globals (structure) +; ((requests int32 :offset-assert 0) +; (effects UNKNOWN 32 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x84 +; :flag-assert #x900000084 +; ) + +; ;; bones +; (deftype merc-effect-bucket-info (structure) +; ((color-fade uint32 :offset-assert 0) +; (use-mercneric uint8 :offset-assert 4) +; (ignore-alpha uint8 :offset-assert 5) +; (pad0 uint8 :offset-assert 6) +; (pad1 uint8 :offset-assert 7) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; bones +; (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 UNKNOWN 16 :offset-assert 124) +; ) +; :method-count-assert 9 +; :size-assert #xfc +; :flag-assert #x9000000fc +; ) + +; ;; 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 +; ) + +; ;; generic-tie +; (deftype gsf-vertex (structure) +; () +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ;; bad type dec string: [~8x] gsf-vertex~% +; ) + +; ;; 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) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; shadow-cpu +; (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) +; (center vector :inline :offset-assert 64) +; (plane vector :inline :offset-assert 80) +; (top-plane vector :inline :offset-assert 96) +; (near-plane vector :inline :offset-assert 112) +; (light-dir vector :inline :offset-assert 128) +; (vtx-min vector :inline :offset-assert 144) +; (data UNKNOWN :dynamic :offset-assert 160) +; ) +; :method-count-assert 9 +; :size-assert #xa0 +; :flag-assert #x9000000a0 +; ) + +; ;; 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 UNKNOWN 2 :offset-assert 96) +; (adgif gs-gif-tag :inline :offset-assert 128) +; (texflush ad-cmd :inline :offset-assert 144) +; (flush ad-cmd :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 +; ) + +; ;; shadow-vu1 +; (deftype shadow-vu1-gifbuf-template (structure) +; ((adgif gs-gif-tag :inline :offset-assert 0) +; (ad ad-cmd :inline :offset-assert 16) +; (flush ad-cmd :inline :offset-assert 32) +; (trigif gs-gif-tag :inline :offset-assert 48) +; (quadgif gs-gif-tag :inline :offset-assert 64) +; ) +; :method-count-assert 9 +; :size-assert #x50 +; :flag-assert #x900000050 +; ) + +; ;; 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 +; ) + +; ;; draw-node +; (deftype drawable-inline-array-node (drawable-inline-array) +; () +; :method-count-assert 18 +; :size-assert #x44 +; :flag-assert #x1200000044 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; shrubbery +; (deftype prototype-shrubbery (drawable-inline-array) +; () +; :method-count-assert 18 +; :size-assert #x44 +; :flag-assert #x1200000044 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; tfrag +; (deftype drawable-inline-array-tfrag (drawable-inline-array) +; () +; :method-count-assert 18 +; :size-assert #x64 +; :flag-assert #x1200000064 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; tie +; (deftype drawable-inline-array-instance-tie (drawable-inline-array) +; () +; :method-count-assert 18 +; :size-assert #x64 +; :flag-assert #x1200000064 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; tie +; (deftype prototype-tie (drawable-inline-array) +; () +; :method-count-assert 18 +; :size-assert #x64 +; :flag-assert #x1200000064 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; tie +; (deftype tie-consts (structure) +; ((data UNKNOWN 24 :offset-assert 0) +; (vector UNKNOWN 6 :offset-assert 0) +; (quads UNKNOWN 6 :offset-assert 0) +; (adgif qword :inline :offset-assert 0) +; (strgif qword :inline :offset-assert 16) +; (extra qword :inline :offset-assert 32) +; (gifbufs qword :inline :offset-assert 48) +; (clrbufs qword :inline :offset-assert 64) +; (misc qword :inline :offset-assert 80) +; (atestgif qword :inline :offset-assert 96) +; (atest UNKNOWN 2 :offset-assert 112) +; (atest-tra ad-cmd :inline :offset-assert 112) +; (atest-def ad-cmd :inline :offset-assert 128) +; ) +; :method-count-assert 9 +; :size-assert #x90 +; :flag-assert #x900000090 +; ) + +; ;; 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 ad-cmd :inline :offset-assert 144) +; (atest-def ad-cmd :inline :offset-assert 160) +; ) +; :method-count-assert 9 +; :size-assert #xb0 +; :flag-assert #x9000000b0 +; ) + +; ;; tie-methods +; (deftype tie-instance-debug (structure) +; ((max-instance uint32 :offset-assert 0) +; (min-instance uint32 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; sparticle-launcher +; (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 UNKNOWN 1 :offset-assert 0) +; (data UNKNOWN 1 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x1c +; :flag-assert #x90000001c +; ) + +; ;; sparticle-launcher +; (deftype sparticle-launcher (basic) +; () +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ;; too many basic blocks +; ) + +; ;; sparticle-launcher +; (deftype sp-queued-launch-particles (structure) +; ((sp-system basic :offset-assert 0) +; (sp-launcher basic :offset-assert 4) +; (pos vector :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; sparticle-launcher +; (deftype sp-launch-queue (basic) +; ((in-use int32 :offset-assert 4) +; (queue UNKNOWN 32 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x410 +; :flag-assert #x900000410 +; ) + +; ;; sparticle-launcher +; (deftype particle-adgif-cache (basic) +; ((used int32 :offset-assert 4) +; (last uint16 :offset-assert 8) +; (lastgif adgif-shader :offset-assert 12) +; (tidhash UNKNOWN 80 :offset-assert 16) +; (spadgif UNKNOWN 80 :offset-assert 176) +; ) +; :method-count-assert 9 +; :size-assert #x19b0 +; :flag-assert #x9000019b0 +; ) + +; ;; loader +; (deftype load-dir (basic) +; () +; :method-count-assert 11 +; :size-assert #x10 +; :flag-assert #xb00000010 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; task-control-h +; (deftype task-cstage (structure) +; ((game-task uint8 :offset-assert 0) +; (status uint64 :offset-assert 8) +; (flags uint8 :offset-assert 16) +; (condition basic :offset-assert 20) +; ) +; :method-count-assert 16 +; :size-assert #x18 +; :flag-assert #x1000000018 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; ) +; ) + +; ;; task-control-h +; (deftype task-control (basic) +; ((current-stage int16 :offset-assert 4) +; (stage basic :offset-assert 8) +; ) +; :method-count-assert 19 +; :size-assert #xc +; :flag-assert #x130000000c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; ) +; ) + +; ;; task-control-h +; (deftype ambient-control (structure) +; ((last-ambient-time uint64 :offset-assert 0) +; (last-ambient basic :offset-assert 8) +; (last-ambient-id uint32 :offset-assert 12) +; ) +; :method-count-assert 12 +; :size-assert #x10 +; :flag-assert #xc00000010 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; task-control-h +; (deftype process-taskable (process-drawable) +; ((~Ttasks basic :offset-assert 176) +; (~Tquery gui-query :inline :offset-assert 180) +; (~Told-target-pos transformq :inline :offset-assert 208) +; (~Tcell-for-task uint8 :offset-assert 256) +; (~Tcell-x uint64 :offset-assert 264) +; (~Tcam-joint-index int32 :offset-assert 272) +; (~Tskippable basic :offset-assert 276) +; (~Tblend-on-exit basic :offset-assert 280) +; (~Tcamera uint64 :offset-assert 288) +; (~Twill-talk basic :offset-assert 296) +; (~Ttalk-message uint32 :offset-assert 300) +; (~Tlast-talk uint64 :offset-assert 304) +; (~Tbounce-away basic :offset-assert 312) +; (~Tambient ambient-control :inline :offset-assert 320) +; (~Tcenter-joint-index int32 :offset-assert 336) +; (~Tdraw-bounds-y-offset float :offset-assert 340) +; (~Tneck-joint-index int32 :offset-assert 344) +; (~Tfuel-cell-anim basic :offset-assert 348) +; (~Tsound-flava uint8 :offset-assert 352) +; (~Thave-flava basic :offset-assert 356) +; (~Tmusic basic :offset-assert 360) +; (~Thave-music basic :offset-assert 364) +; (~Tbeen-kicked basic :offset-assert 368) +; (~Tcur-trans-hook basic :offset-assert 372) +; (~Tshadow-backup basic :offset-assert 376) +; ) +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; game-save +; (deftype game-save-tag (structure) +; ((user-object UNKNOWN 2 :offset-assert 0) +; (user-uint64 uint64 :offset-assert 0) +; (user-float0 float :offset-assert 0) +; (user-float UNKNOWN 2 :offset-assert 0) +; (user-int32 UNKNOWN 2 :offset-assert 0) +; (user-uint32 UNKNOWN 2 :offset-assert 0) +; (user-int16 UNKNOWN 4 :offset-assert 0) +; (user-uint16 UNKNOWN 4 :offset-assert 0) +; (user-int8 UNKNOWN 8 :offset-assert 0) +; (user-int80 int8 :offset-assert 0) +; (user-int81 int8 :offset-assert 1) +; (user-uint8 UNKNOWN 8 :offset-assert 0) +; (elt-count int32 :offset-assert 8) +; (elt-size uint16 :offset-assert 12) +; (elt-type uint16 :offset-assert 14) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; game-save +; (deftype game-save (basic) +; ((version int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (length int32 :offset-assert 12) +; (info-int32 UNKNOWN 16 :offset-assert 16) +; (info-int8 UNKNOWN 64 :offset-assert 16) +; (level-index int32 :offset-assert 16) +; (fuel-cell-count float :offset-assert 20) +; (money-count float :offset-assert 24) +; (buzzer-count float :offset-assert 28) +; (completion-percentage float :offset-assert 32) +; (minute uint8 :offset-assert 36) +; (hour uint8 :offset-assert 37) +; (week uint8 :offset-assert 38) +; (day uint8 :offset-assert 39) +; (month uint8 :offset-assert 40) +; (year uint8 :offset-assert 41) +; (new-game int32 :offset-assert 44) +; (tag UNKNOWN :dynamic :offset-assert 80) +; ) +; :method-count-assert 12 +; :size-assert #x50 +; :flag-assert #xc00000050 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; game-save +; (deftype game-save (basic) +; () +; :method-count-assert 12 +; :size-assert #x50 +; :flag-assert #xc00000050 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; game-save +; (deftype auto-save (process) +; ((~Tcard int32 :offset-assert 112) +; (~Tslot int32 :offset-assert 116) +; (~Twhich int32 :offset-assert 120) +; (~Tbuffer kheap :offset-assert 124) +; (~Tmode basic :offset-assert 128) +; (~Tresult uint32 :offset-assert 132) +; (~Tsave basic :offset-assert 136) +; (~Tinfo mc-slot-info :inline :offset-assert 140) +; (~Tnotify uint64 :offset-assert 440) +; (~Tstate-time uint64 :offset-assert 448) +; (~Tpart basic :offset-assert 456) +; ) +; :method-count-assert 23 +; :size-assert #x1cc +; :flag-assert #x17016001cc +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; mood +; (deftype flames-state (structure) +; ((index uint8 :offset-assert 0) +; (time uint8 :offset-assert 1) +; (length uint8 :offset-assert 2) +; (height uint8 :offset-assert 3) +; ) +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ) + +; ;; mood +; (deftype lightning-state (structure) +; ((val uint8 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x1 +; :flag-assert #x900000001 +; ) + +; ;; mood +; (deftype light-time-state (structure) +; ((time uint8 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x1 +; :flag-assert #x900000001 +; ) + +; ;; mood +; (deftype light-state (structure) +; ((fade uint8 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x1 +; :flag-assert #x900000001 +; ) + +; ;; mood +; (deftype lava-state (structure) +; ((scale UNKNOWN 4 :offset-assert 0) +; (time uint8 :offset-assert 16) +; (last-index uint8 :offset-assert 17) +; ) +; :method-count-assert 9 +; :size-assert #x12 +; :flag-assert #x900000012 +; ) + +; ;; mood +; (deftype misty-states (structure) +; ((flames flames-state :inline :offset-assert 0) +; (light0 light-state :inline :offset-assert 4) +; (light1 light-state :inline :offset-assert 5) +; (time0 light-time-state :inline :offset-assert 6) +; (time1 light-time-state :inline :offset-assert 7) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; mood +; (deftype swamp-village2-states (structure) +; ((flames flames-state :inline :offset-assert 0) +; (lightning lightning-state :inline :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x5 +; :flag-assert #x900000005 +; ) + +; ;; mood +; (deftype village1-states (structure) +; ((flames flames-state :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ) + +; ;; mood +; (deftype jungle-states (structure) +; ((light light-state :inline :offset-assert 0) +; (time light-time-state :inline :offset-assert 1) +; (one-shot uint8 :offset-assert 2) +; ) +; :method-count-assert 9 +; :size-assert #x3 +; :flag-assert #x900000003 +; ) + +; ;; mood +; (deftype sunken-states (structure) +; ((light light-state :inline :offset-assert 0) +; (time light-time-state :inline :offset-assert 1) +; ) +; :method-count-assert 9 +; :size-assert #x2 +; :flag-assert #x900000002 +; ) + +; ;; mood +; (deftype rolling-states (structure) +; ((light0 light-state :inline :offset-assert 0) +; (light1 light-state :inline :offset-assert 1) +; (light2 light-state :inline :offset-assert 2) +; (light3 light-state :inline :offset-assert 3) +; (time light-time-state :inline :offset-assert 4) +; (lightning lightning-state :inline :offset-assert 5) +; ) +; :method-count-assert 9 +; :size-assert #x6 +; :flag-assert #x900000006 +; ) + +; ;; mood +; (deftype firecanyon-states (structure) +; ((lava lava-state :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x12 +; :flag-assert #x900000012 +; ) + +; ;; mood +; (deftype training-states (structure) +; ((light light-state :inline :offset-assert 0) +; (time light-time-state :inline :offset-assert 1) +; ) +; :method-count-assert 9 +; :size-assert #x2 +; :flag-assert #x900000002 +; ) + +; ;; mood +; (deftype maincave-states (structure) +; ((flames flames-state :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ) + +; ;; mood +; (deftype robocave-states (structure) +; ((flames flames-state :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ) + +; ;; mood +; (deftype snow-states (structure) +; ((flames flames-state :inline :offset-assert 0) +; (light light-state :inline :offset-assert 4) +; (time light-time-state :inline :offset-assert 5) +; (one-shot uint8 :offset-assert 6) +; (interp float :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; mood +; (deftype village3-states (structure) +; ((flames flames-state :inline :offset-assert 0) +; (scale float :offset-assert 4) +; (lava lava-state :inline :offset-assert 8) +; (lava-time float :offset-assert 28) +; (time uint8 :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x21 +; :flag-assert #x900000021 +; ) + +; ;; mood +; (deftype lavatube-states (structure) +; ((lava lava-state :inline :offset-assert 0) +; (light light-state :inline :offset-assert 18) +; (time light-time-state :inline :offset-assert 19) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; mood +; (deftype ogre-states (structure) +; ((lava lava-state :inline :offset-assert 0) +; (lightning lightning-state :inline :offset-assert 18) +; (lava-time float :offset-assert 20) +; (lava-fade float :offset-assert 24) +; ) +; :method-count-assert 9 +; :size-assert #x1c +; :flag-assert #x90000001c +; ) + +; ;; mood +; (deftype finalboss-states (structure) +; ((start-time uint64 :offset-assert 0) +; (secret-time uint64 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; mood +; (deftype citadel-states (structure) +; ((flames flames-state :inline :offset-assert 0) +; (light light-state :inline :offset-assert 4) +; (time light-time-state :inline :offset-assert 5) +; (flicker-off uint8 :offset-assert 6) +; (flicker-on uint8 :offset-assert 7) +; (shield-fade float :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; sky +; (deftype sky-frame-data (structure) +; ((data UNKNOWN 18 :offset-assert 0) +; (world-homo-matrix matrix :inline :offset-assert 0) +; (hmge-scale vector :inline :offset-assert 64) +; (hvdf-offset vector :inline :offset-assert 80) +; (consts vector :inline :offset-assert 96) +; (pfog0 float :offset-assert 96) +; (radius float :offset-assert 100) +; (nokick float :offset-assert 108) +; (strip-giftag qword :inline :offset-assert 112) +; (col-adgif qword :inline :offset-assert 128) +; (save UNKNOWN 5 :offset-assert 144) +; (sun-fan-giftag qword :inline :offset-assert 224) +; (sun-strip-giftag qword :inline :offset-assert 240) +; (sun-alpha qword :inline :offset-assert 256) +; (sun-alpha-giftag qword :inline :offset-assert 272) +; ) +; :method-count-assert 9 +; :size-assert #x120 +; :flag-assert #x900000120 +; ) + +; ;; sky-tng +; (deftype sky-vertex (structure) +; () +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ;; bad type dec string: sky-vertex [~X]:~% +; ) + +; ;; load-boundary-h +; (deftype lbvtx (structure) +; ((x float :offset-assert 0) +; (y float :offset-assert 4) +; (z float :offset-assert 8) +; (v0 uint8 :offset-assert 12) +; (v1 uint8 :offset-assert 13) +; (v2 uint8 :offset-assert 14) +; (ix uint8 :offset-assert 15) +; (quad uint128 :offset-assert 0) +; (v vector :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; load-boundary-h +; (deftype load-boundary-crossing-command (structure) +; ((cmd uint8 :offset-assert 0) +; (bparm UNKNOWN 3 :offset-assert 1) +; (parm UNKNOWN 2 :offset-assert 4) +; (lev0 basic :offset-assert 4) +; (lev1 basic :offset-assert 8) +; (displev basic :offset-assert 4) +; (dispcmd basic :offset-assert 8) +; (nick basic :offset-assert 4) +; (forcelev basic :offset-assert 4) +; (forceonoff basic :offset-assert 8) +; (checkname basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; load-boundary-h +; (deftype load-boundary (basic) +; ((num-points uint16 :offset-assert 4) +; (flags uint8 :offset-assert 6) +; (top-plane float :offset-assert 8) +; (bot-plane float :offset-assert 12) +; (tri-cnt int32 :offset-assert 16) +; (next basic :offset-assert 20) +; (cmd-fwd load-boundary-crossing-command :inline :offset-assert 24) +; (cmd-bwd load-boundary-crossing-command :inline :offset-assert 36) +; (rejector vector :inline :offset-assert 48) +; (data UNKNOWN 1 :offset-assert 64) +; ) +; :method-count-assert 9 +; :size-assert #x50 +; :flag-assert #x900000050 +; ) + +; ;; load-boundary +; (deftype lb-editor-parms (basic) +; ((boundary basic :offset-assert 4) +; (vertex int32 :offset-assert 8) +; (x-origin float :offset-assert 12) +; (z-origin float :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; text +; (deftype game-text-info (basic) +; () +; :method-count-assert 10 +; :size-assert #x10 +; :flag-assert #xa00000010 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; 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 +; ) + +; ;; collide-probe +; (deftype collide-probe-stack (structure) +; ((data UNKNOWN 1024 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x4000 +; :flag-assert #x900004000 +; ) + +; ;; 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 +; ) + +; ;; collide-mesh +; (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 +; ) + +; ;; collide-mesh +; (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 +; ) + +; ;; 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 +; ) + +; ;; 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 +; ) + +; ;; merc-death +; (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 basic :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; water-h +; (deftype water-control (basic) +; ((flags uint32 :offset-assert 4) +; (process basic :offset-assert 8) +; (joint-index int32 :offset-assert 12) +; (top-y-offset float :offset-assert 16) +; (ripple-size meters :offset-assert 20) +; (enter-water-time uint64 :offset-assert 24) +; (wade-time uint64 :offset-assert 32) +; (on-water-time uint64 :offset-assert 40) +; (enter-swim-time uint64 :offset-assert 48) +; (swim-time uint64 :offset-assert 56) +; (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) +; (height meters :offset-assert 84) +; (height-offset UNKNOWN 4 :offset-assert 88) +; (real-ocean-offset meters :offset-assert 88) +; (ocean-offset meters :offset-assert 92) +; (bob-offset meters :offset-assert 96) +; (align-offset meters :offset-assert 100) +; (swim-depth meters :offset-assert 104) +; (bob smush-control :inline :offset-assert 112) +; (volume uint64 :offset-assert 144) +; (bottom UNKNOWN 2 :offset-assert 160) +; (top UNKNOWN 2 :offset-assert 192) +; (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) +; (drip-speed float :offset-assert 272) +; (drip-height meters :offset-assert 276) +; (drip-mult float :offset-assert 280) +; ) +; :method-count-assert 17 +; :size-assert #x11c +; :flag-assert #x110000011c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; ) +; ) + +; ;; water-h +; (deftype water-vol (process-drawable) +; ((~Twater-height meters :offset-assert 176) +; (~Twade-height meters :offset-assert 180) +; (~Tswim-height meters :offset-assert 184) +; (~Tbottom-height meters :offset-assert 188) +; (~Tattack-event basic :offset-assert 192) +; (~Ttarget uint64 :offset-assert 200) +; (~Tflags uint32 :offset-assert 208) +; ) +; :method-count-assert 30 +; :size-assert #xd4 +; :flag-assert #x1e007000d4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; cam-master +; (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 +; ) + +; ;; cam-master +; (deftype list-keeper (process) +; ((~Tdummy float :offset-assert 112) +; ) +; :method-count-assert 14 +; :size-assert #x74 +; :flag-assert #xe00100074 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; cam-states +; (deftype cam-eye-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-states +; (deftype cam-billy-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-states +; (deftype cam-string-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-states +; (deftype los-dist (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-states +; (deftype collide-los-dist-info (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-states +; (deftype collide-los-result (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-states +; (deftype cam-stick-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-states +; (deftype cam-bike-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-states-dbg +; (deftype cam-point-watch-bank (basic) +; ((speed float :offset-assert 4) +; (rot-speed deg :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; cam-states-dbg +; (deftype cam-free-bank (basic) +; ((speed float :offset-assert 4) +; (rot-speed deg :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; cam-states-dbg +; (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 +; ) + +; ;; cam-states-dbg +; (deftype camera-orbit-info (structure) +; ((radius float :offset-assert 0) +; (rot float :offset-assert 4) +; (target-off vector :inline :offset-assert 16) +; (orbit-off vector :inline :offset-assert 32) +; (radius-lerp float :offset-assert 48) +; ) +; :method-count-assert 9 +; :size-assert #x34 +; :flag-assert #x900000034 +; ) + +; ;; cam-states-dbg +; (deftype CAM_ORBIT-bank (basic) +; ((RADIUS_MAX float :offset-assert 4) +; (RADIUS_MIN float :offset-assert 8) +; (TARGET_OFF_ADJUST float :offset-assert 12) +; (ORBIT_OFF_ADJUST float :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; vol-h +; (deftype plane-volume (structure) +; ((volume-type basic :offset-assert 0) +; (point-count int16 :offset-assert 4) +; (normal-count int16 :offset-assert 6) +; (first-point vector :offset-assert 8) +; (first-normal vector :offset-assert 12) +; (num-planes int32 :offset-assert 16) +; (plane uint32 :offset-assert 20) +; ) +; :method-count-assert 12 +; :size-assert #x18 +; :flag-assert #xc00000018 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; vol-h +; (deftype vol-control (basic) +; ((flags uint32 :offset-assert 4) +; (process basic :offset-assert 8) +; (pos-vol-count int32 :offset-assert 12) +; (pos-vol UNKNOWN 32 :offset-assert 16) +; (neg-vol-count int32 :offset-assert 784) +; (neg-vol UNKNOWN 32 :offset-assert 788) +; (debug-point basic :offset-assert 1556) +; (debug-normal basic :offset-assert 1560) +; ) +; :method-count-assert 12 +; :size-assert #x61c +; :flag-assert #xc0000061c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; cam-layout +; (deftype cam-layout-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype clm-basic (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype clm-item-action (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype clm-item (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype clm-list-item (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype clm-list (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype clm (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype volume-descriptor-array (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype cam-layout (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process) parent was UNKNOWN +; ) + +; ;; cam-layout +; (deftype interp-test-info (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-layout +; (deftype clmf-cam-flag-toggle-info (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; cam-debug +; (deftype cam-dbg-scratch (structure) +; ((linevec4w UNKNOWN 2 :offset-assert 0) +; (color vector :inline :offset-assert 32) +; (plotvec UNKNOWN 2 :offset-assert 48) +; (linevec UNKNOWN 2 :offset-assert 80) +; (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 UNKNOWN 3 :offset-assert 192) +; (bboxvec UNKNOWN 6 :offset-assert 240) +; (fov-vv UNKNOWN 4 :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 +; ) + +; ;; cam-debug +; (deftype cam-debug-tri (structure) +; ((vertex UNKNOWN 3 :offset-assert 0) +; (intersect vector :inline :offset-assert 48) +; (color vector4w :offset-assert 64) +; ) +; :method-count-assert 9 +; :size-assert #x44 +; :flag-assert #x900000044 +; ) + +; ;; cam-debug +; (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 basic :offset-assert 164) +; ) +; :method-count-assert 9 +; :size-assert #xa8 +; :flag-assert #x9000000a8 +; ) + +; ;; cam-debug +; (deftype cam-collision-record-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; generic-obs +; (deftype target-start (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; generic-obs +; (deftype camera-start (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; generic-obs +; (deftype med-res-level (process-drawable) +; ((~Tlevel basic :offset-assert 176) +; (~Tpart-mode basic :offset-assert 180) +; (~Tindex int32 :offset-assert 184) +; ) +; :method-count-assert 20 +; :size-assert #xbc +; :flag-assert #x14005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; generic-obs +; (deftype launcher (process-drawable) +; ((~Tspring-height meters :offset-assert 176) +; (~Tcamera basic :offset-assert 180) +; (~Tactive-distance float :offset-assert 184) +; (~Tseek-time uint64 :offset-assert 192) +; (~Tdest vector :inline :offset-assert 208) +; (~Tsound-id uint32 :offset-assert 224) +; ) +; :method-count-assert 20 +; :size-assert #xe4 +; :flag-assert #x14008000e4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; 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) +; (wheel-duration uint64 :offset-assert 80) +; (wheel-jump-pre-window uint64 :offset-assert 88) +; (wheel-jump-post-window uint64 :offset-assert 96) +; (wheel-timeout uint64 :offset-assert 104) +; (wheel-speed-min meters :offset-assert 112) +; (wheel-speed-inc meters :offset-assert 116) +; (wheel-flip-duration uint64 :offset-assert 120) +; (wheel-flip-height meters :offset-assert 128) +; (wheel-flip-dist meters :offset-assert 132) +; (wheel-flip-art-height meters :offset-assert 136) +; (wheel-flip-art-dist meters :offset-assert 140) +; (duck-slide-distance meters :offset-assert 144) +; (fall-far meters :offset-assert 148) +; (fall-far-inc meters :offset-assert 152) +; (attack-timeout uint64 :offset-assert 160) +; (ground-timeout uint64 :offset-assert 168) +; (slide-down-timeout uint64 :offset-assert 176) +; (fall-timeout uint64 :offset-assert 184) +; (fall-stumble-threshold meters :offset-assert 192) +; (yellow-projectile-speed meters :offset-assert 196) +; (hit-invulnerable-timeout uint64 :offset-assert 200) +; (run-cycle-length float :offset-assert 208) +; (walk-cycle-dist meters :offset-assert 212) +; (walk-up-cycle-dist meters :offset-assert 216) +; (walk-down-cycle-dist meters :offset-assert 220) +; (walk-side-cycle-dist meters :offset-assert 224) +; (run-cycle-dist meters :offset-assert 228) +; (run-up-cycle-dist meters :offset-assert 232) +; (run-down-cycle-dist meters :offset-assert 236) +; (run-side-cycle-dist meters :offset-assert 240) +; (run-wall-cycle-dist meters :offset-assert 244) +; (duck-walk-cycle-dist meters :offset-assert 248) +; (wade-shallow-walk-cycle-dist meters :offset-assert 252) +; (wade-deep-walk-cycle-dist meters :offset-assert 256) +; (smack-surface-dist meters :offset-assert 260) +; (smack-surface-height meters :offset-assert 264) +; (min-dive-depth meters :offset-assert 268) +; (root-radius meters :offset-assert 272) +; (root-offset vector :inline :offset-assert 288) +; (body-radius meters :offset-assert 304) +; (edge-radius meters :offset-assert 308) +; (edge-offset vector :inline :offset-assert 320) +; (head-radius meters :offset-assert 336) +; (head-height meters :offset-assert 340) +; (head-offset vector :inline :offset-assert 352) +; (spin-radius meters :offset-assert 368) +; (spin-offset vector :inline :offset-assert 384) +; (duck-spin-radius meters :offset-assert 400) +; (duck-spin-offset vector :inline :offset-assert 416) +; (punch-radius meters :offset-assert 432) +; (punch-offset vector :inline :offset-assert 448) +; (uppercut-radius meters :offset-assert 464) +; (uppercut0-offset vector :inline :offset-assert 480) +; (uppercut1-offset vector :inline :offset-assert 496) +; (flop-radius meters :offset-assert 512) +; (flop0-offset vector :inline :offset-assert 528) +; (flop1-offset vector :inline :offset-assert 544) +; (stuck-time useconds :offset-assert 560) +; (stuck-timeout useconds :offset-assert 568) +; (stuck-distance meters :offset-assert 576) +; (tongue-pull-speed-min float :offset-assert 580) +; (tongue-pull-speed-max float :offset-assert 584) +; (yellow-attack-timeout uint64 :offset-assert 592) +; ) +; :method-count-assert 9 +; :size-assert #x258 +; :flag-assert #x900000258 +; ) + +; ;; voicebox +; (deftype camera-voicebox (camera-slave) +; () +; :method-count-assert 14 +; :size-assert #xa04 +; :flag-assert #xe09a00a04 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; voicebox +; (deftype voicebox (process-drawable) +; ((~Tbase-trans vector :inline :offset-assert 176) +; (~Tseeker cam-float-seeker :inline :offset-assert 192) +; (~Tblend float :offset-assert 216) +; (~Ttwist float :offset-assert 220) +; (~Thint uint64 :offset-assert 224) +; ) +; :method-count-assert 23 +; :size-assert #xe8 +; :flag-assert #x17008000e8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; target2 +; (deftype first-person-hud (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process) parent was UNKNOWN +; ) + +; ;; menu +; (deftype debug-menu-context (basic) +; ((is-active basic :offset-assert 4) +; (sel-length int32 :offset-assert 8) +; (sel-menu UNKNOWN 8 :offset-assert 12) +; (root-menu basic :offset-assert 44) +; (joypad-func basic :offset-assert 48) +; (joypad-item basic :offset-assert 52) +; (font basic :offset-assert 56) +; (is-hidden basic :offset-assert 60) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; menu +; (deftype debug-menu-node (basic) +; ((name basic :offset-assert 4) +; (parent basic :offset-assert 8) +; (refresh-delay int32 :offset-assert 12) +; (refresh-ctr int32 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; menu +; (deftype debug-menu (debug-menu-node) +; ((name basic :offset-assert 4) +; (parent basic :offset-assert 8) +; (refresh-delay int32 :offset-assert 12) +; (refresh-ctr int32 :offset-assert 16) +; (context basic :offset-assert 20) +; (selected-item basic :offset-assert 24) +; (pix-width int32 :offset-assert 28) +; (pix-height int32 :offset-assert 32) +; (items basic :offset-assert 36) +; ) +; :method-count-assert 9 +; :size-assert #x28 +; :flag-assert #x900000028 +; ) + +; ;; menu +; (deftype debug-menu-item (debug-menu-node) +; ((name basic :offset-assert 4) +; (parent basic :offset-assert 8) +; (refresh-delay int32 :offset-assert 12) +; (refresh-ctr int32 :offset-assert 16) +; (id int32 :offset-assert 20) +; ) +; :method-count-assert 9 +; :size-assert #x18 +; :flag-assert #x900000018 +; ) + +; ;; menu +; (deftype debug-menu-item-submenu (debug-menu-item) +; ((name basic :offset-assert 4) +; (parent basic :offset-assert 8) +; (refresh-delay int32 :offset-assert 12) +; (refresh-ctr int32 :offset-assert 16) +; (id int32 :offset-assert 20) +; (submenu basic :offset-assert 24) +; ) +; :method-count-assert 9 +; :size-assert #x1c +; :flag-assert #x90000001c +; ) + +; ;; menu +; (deftype debug-menu-item-function (debug-menu-item) +; ((name basic :offset-assert 4) +; (parent basic :offset-assert 8) +; (refresh-delay int32 :offset-assert 12) +; (refresh-ctr int32 :offset-assert 16) +; (id int32 :offset-assert 20) +; (activate-func basic :offset-assert 24) +; (hilite-timer int8 :offset-assert 28) +; ) +; :method-count-assert 9 +; :size-assert #x1d +; :flag-assert #x90000001d +; ) + +; ;; menu +; (deftype debug-menu-item-flag (debug-menu-item) +; ((name basic :offset-assert 4) +; (parent basic :offset-assert 8) +; (refresh-delay int32 :offset-assert 12) +; (refresh-ctr int32 :offset-assert 16) +; (id int32 :offset-assert 20) +; (activate-func basic :offset-assert 24) +; (is-on basic :offset-assert 28) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; menu +; (deftype debug-menu-item-var (debug-menu-item) +; ((name basic :offset-assert 4) +; (parent basic :offset-assert 8) +; (refresh-delay int32 :offset-assert 12) +; (refresh-ctr int32 :offset-assert 16) +; (id int32 :offset-assert 20) +; (display-str basic :offset-assert 24) +; (grabbed-joypad-p basic :offset-assert 28) +; (float-p basic :offset-assert 32) +; (range-p basic :offset-assert 36) +; (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 basic :offset-assert 88) +; (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 basic :offset-assert 92) +; (iactivate-func basic :offset-assert 88) +; (ifloat-p basic :offset-assert 96) +; ) +; :method-count-assert 9 +; :size-assert #x64 +; :flag-assert #x900000064 +; ) + +; ;; drawable-group +; (deftype drawable-group (drawable) +; () +; :method-count-assert 18 +; :size-assert #x24 +; :flag-assert #x1200000024 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; ) +; ) + +; ;; collide-cache +; (deftype collide-puls-work (structure) +; ((ignore-pat uint32 :offset-assert 0) +; (tri-out collide-tri-result :offset-assert 4) +; (bsphere sphere :inline :offset-assert 16) +; (move-dist vector :inline :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; collide-cache +; (deftype lsmi-work (structure) +; ((best-u float :offset-assert 0) +; (orig-best-u float :offset-assert 4) +; (action uint32 :offset-assert 8) +; (tri-out collide-tri-result :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x64 +; :flag-assert #x900000064 +; ) + +; ;; memory-usage +; (deftype memory-usage-block (basic) +; () +; :method-count-assert 12 +; :size-assert #x6e0 +; :flag-assert #xc000006e0 +; ;; too many basic blocks +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; entity +; (deftype entity (res-lump) +; () +; :method-count-assert 27 +; :size-assert #x34 +; :flag-assert #x1b00000034 +; ;; unrecognized get op: (set! t9 find-parent-method) parent was res-lump +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; entity +; (deftype entity-actor (entity) +; () +; :method-count-assert 31 +; :size-assert #x50 +; :flag-assert #x1f00000050 +; ;; unrecognized get op: (set! t9 find-parent-method) parent was entity +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; ) +; ) + +; ;; navigate +; (deftype cfs-travel-vec (structure) +; ((dir vector :inline :offset-assert 0) +; (delta-angle float :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; navigate +; (deftype cfs-work (structure) +; ((desired-travel-dist float :offset-assert 0) +; (desired-angle float :offset-assert 4) +; (max-dist float :offset-assert 8) +; (old-angle float :offset-assert 12) +; (modified int32 :offset-assert 16) +; (blocked-mask uint64 :offset-assert 24) +; (travel vector :inline :offset-assert 32) +; (current vector :inline :offset-assert 48) +; (new-travel UNKNOWN 2 :offset-assert 64) +; (temp-travel UNKNOWN 2 :offset-assert 128) +; (prev-dir vector :inline :offset-assert 192) +; (attempt-dir vector :inline :offset-assert 208) +; (tangent UNKNOWN 2 :offset-assert 224) +; ) +; :method-count-assert 9 +; :size-assert #x100 +; :flag-assert #x900000100 +; ) + +; ;; navigate +; (deftype nav-control-cfs-work (structure) +; ((in-dir vector :inline :offset-assert 0) +; (right-dir vector :inline :offset-assert 16) +; (best-dir UNKNOWN 2 :offset-assert 32) +; (temp-dir UNKNOWN 2 :offset-assert 64) +; (away-dir vector :inline :offset-assert 96) +; (best-dir-angle UNKNOWN 2 :offset-assert 112) +; (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 +; ) + +; ;; collectables +; (deftype collectable (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; collectables +; (deftype eco-collectable (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 collectable) parent was UNKNOWN +; ) + +; ;; collectables +; (deftype eco (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype eco-yellow (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype eco-red (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype eco-blue (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype health (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype eco-pill (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype money (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype fuel-cell (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 eco-collectable) parent was UNKNOWN +; ) + +; ;; collectables +; (deftype buzzer (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 eco-collectable) parent was UNKNOWN +; ) + +; ;; collectables +; (deftype ecovalve (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; collectables +; (deftype vent (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; collectables +; (deftype ventyellow (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype ventred (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype ventblue (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; collectables +; (deftype ecovent (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; 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 +; ) + +; ;; crates +; (deftype crate (process-drawable) +; ((~Tsmush smush-control :inline :offset-assert 176) +; (~Tbase vector :inline :offset-assert 208) +; (~Tlook basic :offset-assert 224) +; (~Tdefense basic :offset-assert 228) +; (~Tincomming-attack-id uint64 :offset-assert 232) +; (~Ttarget uint64 :offset-assert 240) +; (~Tchild-count int32 :offset-assert 248) +; (~Tvictory-anim basic :offset-assert 252) +; ) +; :method-count-assert 30 +; :size-assert #x100 +; :flag-assert #x1e00900100 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; crates +; (deftype barrel (crate) +; () +; :method-count-assert 30 +; :size-assert #x100 +; :flag-assert #x1e00900100 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; crates +; (deftype bucket (crate) +; () +; :method-count-assert 30 +; :size-assert #x100 +; :flag-assert #x1e00900100 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; crates +; (deftype crate-buzzer (crate) +; () +; :method-count-assert 30 +; :size-assert #x100 +; :flag-assert #x1e00900100 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; crates +; (deftype pickup-spawner (crate) +; ((~Tblocker basic :offset-assert 256) +; ) +; :method-count-assert 30 +; :size-assert #x104 +; :flag-assert #x1e00a00104 +; ;; inherited inpspect of crate +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; hud-classes +; (deftype hud-pickups (hud) +; () +; :method-count-assert 27 +; :size-assert #x118 +; :flag-assert #x1b00b00118 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; hud-classes +; (deftype hud-health (hud) +; ((~Tscale float :offset-assert 280) +; ) +; :method-count-assert 27 +; :size-assert #x11c +; :flag-assert #x1b00b0011c +; ;; inherited inpspect of hud +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; hud-classes +; (deftype hud-money-all (hud) +; ((~Tx-scale float :offset-assert 280) +; (~Ty-scale float :offset-assert 284) +; (~Ty-pos int32 :offset-assert 288) +; (~Ttotal-orbs int32 :offset-assert 292) +; (~Tlevel-index int32 :offset-assert 296) +; (~Tstart-time uint64 :offset-assert 304) +; ) +; :method-count-assert 27 +; :size-assert #x138 +; :flag-assert #x1b00d00138 +; ;; inherited inpspect of hud +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; hud-classes +; (deftype hud-money (hud) +; ((~Tx-scale float :offset-assert 280) +; (~Ty-scale float :offset-assert 284) +; (~Ty-pos int32 :offset-assert 288) +; ) +; :method-count-assert 27 +; :size-assert #x124 +; :flag-assert #x1b00c00124 +; ;; inherited inpspect of hud +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; hud-classes +; (deftype hud-fuel-cell (hud) +; ((~Tscale-starburst-3-x float :offset-assert 280) +; (~Tscale-starburst-3-y float :offset-assert 284) +; (~Tscale-starburst-4-x float :offset-assert 288) +; (~Tscale-starburst-4-y float :offset-assert 292) +; (~Tscale-icon float :offset-assert 296) +; (~Tscale-center float :offset-assert 300) +; (~Ticon-pos-y int32 :offset-assert 304) +; ) +; :method-count-assert 27 +; :size-assert #x134 +; :flag-assert #x1b00d00134 +; ;; inherited inpspect of hud +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; hud-classes +; (deftype hud-buzzers (hud) +; ((~Tscale float :offset-assert 280) +; (~Ttext-y-offset int32 :offset-assert 284) +; ) +; :method-count-assert 27 +; :size-assert #x120 +; :flag-assert #x1b00b00120 +; ;; inherited inpspect of hud +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; hud-classes +; (deftype hud-power (hud) +; ((~Tscale-timer float :offset-assert 280) +; (~Tscale-backing float :offset-assert 284) +; (~Tscale-blue float :offset-assert 288) +; ) +; :method-count-assert 27 +; :size-assert #x124 +; :flag-assert #x1b00c00124 +; ;; inherited inpspect of hud +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; progress +; (deftype progress-global-state (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; projectiles +; (deftype search-info (structure) +; ((point vector :inline :offset-assert 0) +; (best-point vector :inline :offset-assert 16) +; (match-handle uint64 :offset-assert 32) +; (match basic :offset-assert 40) +; (best float :offset-assert 44) +; (radius float :offset-assert 48) +; (rating uint32 :offset-assert 52) +; (require uint32 :offset-assert 56) +; (mask uint32 :offset-assert 60) +; (rot-base vector :inline :offset-assert 64) +; (rot-range float :offset-assert 80) +; ) +; :method-count-assert 9 +; :size-assert #x54 +; :flag-assert #x900000054 +; ) + +; ;; 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 +; ) + +; ;; glist-h +; (deftype glst-named-node (glst-node) +; ((next glst-node :offset-assert 0) +; (prev glst-node :offset-assert 4) +; (privname basic :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; glist-h +; (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 +; ) + +; ;; anim-tester +; (deftype list-control (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; anim-tester +; (deftype list-field (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; anim-tester +; (deftype DISP_LIST-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; anim-tester +; (deftype anim-tester-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; anim-tester +; (deftype anim-tester (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; anim-tester +; (deftype anim-test-obj (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; anim-tester +; (deftype anim-test-sequence (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; anim-tester +; (deftype anim-test-seq-item (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; anim-tester +; (deftype anim-tester (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; too many basic blocks +; ) + +; ;; viewer +; (deftype viewer (process-drawable) +; ((~Tjanim basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; part-tester +; (deftype part-tester (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process) parent was UNKNOWN +; ) + +; ;; rigid-body-h +; (deftype rigid-body (structure) +; ((mass float :offset-assert 0) +; (inv-mass float :offset-assert 4) +; (lin-momentum-damping-factor float :offset-assert 8) +; (ang-momentum-damping-factor float :offset-assert 12) +; (inertial-tensor matrix :inline :offset-assert 16) +; (inv-inertial-tensor matrix :inline :offset-assert 80) +; (cm-offset-joint vector :inline :offset-assert 144) +; (position vector :inline :offset-assert 160) +; (rotation quaternion :inline :offset-assert 176) +; (lin-momentum vector :inline :offset-assert 192) +; (ang-momentum vector :inline :offset-assert 208) +; (lin-velocity vector :inline :offset-assert 224) +; (ang-velocity vector :inline :offset-assert 240) +; (inv-i-world matrix :inline :offset-assert 256) +; (matrix matrix :inline :offset-assert 320) +; (force vector :inline :offset-assert 384) +; (torque vector :inline :offset-assert 400) +; (max-ang-momentum float :offset-assert 416) +; (max-ang-velocity float :offset-assert 420) +; ) +; :method-count-assert 23 +; :size-assert #x1a8 +; :flag-assert #x17000001a8 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; rigid-body-h +; (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 +; ) + +; ;; water-anim +; (deftype water-anim (water-vol) +; ((~Tlook int32 :offset-assert 212) +; (~Tplay-ambient-sound? basic :offset-assert 216) +; ) +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; inherited inpspect of water-vol +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; water-anim +; (deftype water-anim-look (structure) +; ((skel-group basic :offset-assert 0) +; (anim int32 :offset-assert 4) +; (ambient-sound-spec basic :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; dark-eco-pool +; (deftype dark-eco-pool (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; rigid-body +; (deftype rigid-body-platform-constants (structure) +; ((drag-factor float :offset-assert 0) +; (buoyancy-factor float :offset-assert 4) +; (max-buoyancy-depth meters :offset-assert 8) +; (gravity-factor float :offset-assert 12) +; (gravity meters :offset-assert 16) +; (player-weight meters :offset-assert 20) +; (player-bonk-factor float :offset-assert 24) +; (player-dive-factor float :offset-assert 28) +; (player-force-distance meters :offset-assert 32) +; (player-force-clamp meters :offset-assert 36) +; (player-force-timeout uint64 :offset-assert 40) +; (explosion-force meters :offset-assert 48) +; (linear-damping float :offset-assert 52) +; (angular-damping float :offset-assert 56) +; (control-point-count int32 :offset-assert 60) +; (mass float :offset-assert 64) +; (inertial-tensor-x meters :offset-assert 68) +; (inertial-tensor-y meters :offset-assert 72) +; (inertial-tensor-z meters :offset-assert 76) +; (cm-joint-x meters :offset-assert 80) +; (cm-joint-y meters :offset-assert 84) +; (cm-joint-z meters :offset-assert 88) +; (idle-distance meters :offset-assert 92) +; (platform basic :offset-assert 96) +; (sound-name basic :offset-assert 100) +; ) +; :method-count-assert 9 +; :size-assert #x68 +; :flag-assert #x900000068 +; ) + +; ;; rigid-body +; (deftype rigid-body-control-point-inline-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; rigid-body +; (deftype rigid-body-platform (process-drawable) +; ((~Tinfo rigid-body-platform-constants :offset-assert 176) +; (~Trbody rigid-body :inline :offset-assert 192) +; (~Tcontrol-point-array basic :offset-assert 616) +; (~Tplayer-velocity vector :inline :offset-assert 624) +; (~Tplayer-velocity-prev vector :inline :offset-assert 640) +; (~Tplayer-force-position vector :inline :offset-assert 656) +; (~Tplayer-force vector :inline :offset-assert 672) +; (~Tsim-time-remaining float :offset-assert 688) +; (~Tfloat-height-offset float :offset-assert 692) +; (~Tplayer-attack-id int32 :offset-assert 696) +; (~Tplayer-bonk-timeout uint64 :offset-assert 704) +; (~Twater-anim basic :offset-assert 712) +; (~Tplayer-contact basic :offset-assert 716) +; (~Tplayer-impulse basic :offset-assert 720) +; ) +; :method-count-assert 35 +; :size-assert #x2d4 +; :flag-assert #x23027002d4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; nav-enemy-h +; (deftype nav-enemy-info (basic) +; ((idle-anim int32 :offset-assert 4) +; (walk-anim int32 :offset-assert 8) +; (turn-anim int32 :offset-assert 12) +; (notice-anim int32 :offset-assert 16) +; (run-anim int32 :offset-assert 20) +; (jump-anim int32 :offset-assert 24) +; (jump-land-anim int32 :offset-assert 28) +; (victory-anim int32 :offset-assert 32) +; (taunt-anim int32 :offset-assert 36) +; (die-anim int32 :offset-assert 40) +; (neck-joint int32 :offset-assert 44) +; (player-look-at-joint int32 :offset-assert 48) +; (run-travel-speed meters :offset-assert 52) +; (run-rotate-speed deg :offset-assert 56) +; (run-acceleration meters :offset-assert 60) +; (run-turn-time useconds :offset-assert 64) +; (walk-travel-speed meters :offset-assert 72) +; (walk-rotate-speed deg :offset-assert 76) +; (walk-acceleration meters :offset-assert 80) +; (walk-turn-time useconds :offset-assert 88) +; (attack-shove-back meters :offset-assert 96) +; (attack-shove-up meters :offset-assert 100) +; (shadow-size meters :offset-assert 104) +; (notice-nav-radius meters :offset-assert 108) +; (nav-nearest-y-threshold meters :offset-assert 112) +; (notice-distance meters :offset-assert 116) +; (proximity-notice-distance meters :offset-assert 120) +; (stop-chase-distance meters :offset-assert 124) +; (frustration-distance meters :offset-assert 128) +; (frustration-time uint64 :offset-assert 136) +; (die-anim-hold-frame float :offset-assert 144) +; (jump-anim-start-frame float :offset-assert 148) +; (jump-land-anim-end-frame float :offset-assert 152) +; (jump-height-min meters :offset-assert 156) +; (jump-height-factor float :offset-assert 160) +; (jump-start-anim-speed float :offset-assert 164) +; (shadow-max-y meters :offset-assert 168) +; (shadow-min-y meters :offset-assert 172) +; (shadow-locus-dist meters :offset-assert 176) +; (use-align basic :offset-assert 180) +; (draw-shadow basic :offset-assert 184) +; (move-to-ground basic :offset-assert 188) +; (hover-if-no-ground basic :offset-assert 192) +; (use-momentum basic :offset-assert 196) +; (use-flee basic :offset-assert 200) +; (use-proximity-notice basic :offset-assert 204) +; (use-jump-blocked basic :offset-assert 208) +; (use-jump-patrol basic :offset-assert 212) +; (gnd-collide-with uint64 :offset-assert 216) +; (debug-draw-neck basic :offset-assert 224) +; (debug-draw-jump basic :offset-assert 228) +; ) +; :method-count-assert 9 +; :size-assert #xe8 +; :flag-assert #x9000000e8 +; ) + +; ;; nav-enemy-h +; (deftype nav-enemy (process-drawable) +; ((~Thit-from-dir vector :inline :offset-assert 176) +; (~Tevent-param-point vector :inline :offset-assert 192) +; (~Tfrustration-point vector :inline :offset-assert 208) +; (~Tjump-dest vector :inline :offset-assert 224) +; (~Tjump-trajectory trajectory :inline :offset-assert 240) +; (~Tjump-time uint64 :offset-assert 280) +; (~Tnav-info basic :offset-assert 288) +; (~Ttarget-speed float :offset-assert 292) +; (~Tmomentum-speed float :offset-assert 296) +; (~Tacceleration float :offset-assert 300) +; (~Trotate-speed float :offset-assert 304) +; (~Tturn-time uint64 :offset-assert 312) +; (~Tfrustration-time uint64 :offset-assert 320) +; (~Tspeed-scale float :offset-assert 328) +; (~Tneck basic :offset-assert 332) +; (~Treaction-time uint64 :offset-assert 336) +; (~Tnotice-time uint64 :offset-assert 344) +; (~Tstate-timeout uint64 :offset-assert 352) +; (~Tfree-time uint64 :offset-assert 360) +; (~Ttouch-time uint64 :offset-assert 368) +; (~Tnav-enemy-flags uint32 :offset-assert 376) +; (~Tincomming-attack-id uint64 :offset-assert 384) +; (~Tjump-return-state basic :offset-assert 392) +; (~Trand-gen basic :offset-assert 396) +; ) +; :method-count-assert 76 +; :size-assert #x190 +; :flag-assert #x4c01200190 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; baseplat +; (deftype baseplat (process-drawable) +; ((~Tsmush smush-control :inline :offset-assert 176) +; (~Tbasetrans vector :inline :offset-assert 208) +; (~Tbouncing basic :offset-assert 224) +; ) +; :method-count-assert 27 +; :size-assert #xe4 +; :flag-assert #x1b008000e4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; baseplat +; (deftype eco-door (process-drawable) +; ((~Tspeed float :offset-assert 176) +; (~Topen-distance float :offset-assert 180) +; (~Tclose-distance float :offset-assert 184) +; (~Tout-dir vector :inline :offset-assert 192) +; (~Topen-sound uint128 :offset-assert 208) +; (~Tclose-sound uint128 :offset-assert 224) +; (~Tstate-actor basic :offset-assert 240) +; (~Tflags int32 :offset-assert 244) +; (~Tlocked basic :offset-assert 248) +; (~Tauto-close basic :offset-assert 252) +; (~Tone-way basic :offset-assert 256) +; ) +; :method-count-assert 27 +; :size-assert #x104 +; :flag-assert #x1b00a00104 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; basebutton +; (deftype basebutton (process-drawable) +; ((~Tdown? basic :offset-assert 176) +; (~Tspawned-by-other? basic :offset-assert 180) +; (~Tmove-to? basic :offset-assert 184) +; (~Tnotify-actor basic :offset-assert 188) +; (~Ttimeout float :offset-assert 192) +; (~Tbutton-id int32 :offset-assert 196) +; (~Tevent-going-down basic :offset-assert 200) +; (~Tevent-down basic :offset-assert 204) +; (~Tevent-going-up basic :offset-assert 208) +; (~Tevent-up basic :offset-assert 212) +; (~Tanim-speed float :offset-assert 216) +; (~Tmove-to-pos vector :inline :offset-assert 224) +; (~Tmove-to-quat quaternion :inline :offset-assert 240) +; ) +; :method-count-assert 32 +; :size-assert #x100 +; :flag-assert #x2000900100 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; ) +; ) + +; ;; basebutton +; (deftype warp-gate (process-drawable) +; ((~Tlevel basic :offset-assert 176) +; (~Tlevel-slot int32 :offset-assert 180) +; (~Tmin-slot int32 :offset-assert 184) +; (~Tmax-slot int32 :offset-assert 188) +; ) +; :method-count-assert 24 +; :size-assert #xc0 +; :flag-assert #x18005000c0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +; ;; tippy +; (deftype tippy (structure) +; ((axis vector :inline :offset-assert 0) +; (angle float :offset-assert 16) +; (orig quaternion :inline :offset-assert 32) +; (dist-ratio float :offset-assert 48) +; (damping float :offset-assert 52) +; (1-damping float :offset-assert 56) +; ) +; :method-count-assert 11 +; :size-assert #x3c +; :flag-assert #xb0000003c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; joint-exploder +; (deftype joint-exploder-tuning (structure) +; ((explosion uint64 :offset-assert 0) +; (duration uint64 :offset-assert 8) +; (gravity float :offset-assert 16) +; (rot-speed float :offset-assert 20) +; (fountain-rand-transv-lo vector :inline :offset-assert 32) +; (fountain-rand-transv-hi vector :inline :offset-assert 48) +; (away-from-focal-pt vector :inline :offset-assert 32) +; (away-from-rand-transv-xz-lo float :offset-assert 48) +; (away-from-rand-transv-xz-hi float :offset-assert 52) +; (away-from-rand-transv-y-lo float :offset-assert 56) +; (away-from-rand-transv-y-hi float :offset-assert 60) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; joint-exploder +; (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 +; ) + +; ;; joint-exploder +; (deftype joint-exploder-static-params (basic) +; ((joints basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; joint-exploder +; (deftype joint-exploder-joint (structure) +; ((next int16 :offset-assert 0) +; (prev int16 :offset-assert 2) +; (joint-index int16 :offset-assert 4) +; (rspeed float :offset-assert 8) +; (mat matrix :inline :offset-assert 16) +; (rmat matrix :inline :offset-assert 80) +; (transv vector :inline :offset-assert 144) +; (prev-pos vector :inline :offset-assert 160) +; ) +; :method-count-assert 9 +; :size-assert #xb0 +; :flag-assert #x9000000b0 +; ) + +; ;; joint-exploder +; (deftype joint-exploder-joints (basic) +; ((num-joints int32 :offset-assert 4) +; (joint UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; joint-exploder +; (deftype joint-exploder-list (structure) +; ((head int32 :offset-assert 0) +; (pre-moved? basic :offset-assert 4) +; (bbox-valid? basic :offset-assert 8) +; (bbox bounding-box :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; joint-exploder +; (deftype joint-exploder (process-drawable) +; ((~Tdie-if-below-y float :offset-assert 176) +; (~Tdie-if-beyond-xz-dist-sqrd float :offset-assert 180) +; (~Tjoints basic :offset-assert 184) +; (~Tstatic-params basic :offset-assert 188) +; (~Tanim basic :offset-assert 192) +; (~Tscale-vector vector :inline :offset-assert 208) +; (~Ttuning joint-exploder-tuning :inline :offset-assert 224) +; (~Tlists UNKNOWN 5 :offset-assert 288) +; ) +; :method-count-assert 29 +; :size-assert #x210 +; :flag-assert #x1d01a00210 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; babak +; (deftype babak (nav-enemy) +; () +; :method-count-assert 76 +; :size-assert #x190 +; :flag-assert #x4c01200190 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; sharkey +; (deftype sharkey (nav-enemy) +; ((~Tdir vector :inline :offset-assert 400) +; (~Tspawn-point vector :inline :offset-assert 416) +; (~Tscale float :offset-assert 432) +; (~Tanim-speed float :offset-assert 436) +; (~Ty-max meters :offset-assert 440) +; (~Ty-min meters :offset-assert 444) +; (~Tattack-time float :offset-assert 448) +; (~Tplayer-water-time uint64 :offset-assert 456) +; (~Tplayer-in-water basic :offset-assert 464) +; (~Tlast-y float :offset-assert 468) +; (~Tspawn-distance meters :offset-assert 472) +; (~Tchase-speed meters :offset-assert 476) +; (~Ty-speed meters :offset-assert 480) +; (~Tsound-id uint32 :offset-assert 484) +; (~Tenable-patrol basic :offset-assert 488) +; ) +; :method-count-assert 76 +; :size-assert #x1ec +; :flag-assert #x4c018001ec +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; orb-cache +; (deftype orb-cache-top (baseplat) +; ((~Tactive-distance float :offset-assert 228) +; (~Tinactive-distance float :offset-assert 232) +; (~Tmoney-list UNKNOWN 60 :offset-assert 240) +; (~Tmoney-pos-list UNKNOWN 60 :offset-assert 720) +; (~Tmoney-pos-actual UNKNOWN 60 :offset-assert 960) +; (~Tplatform-pos float :offset-assert 1200) +; (~Troot-pos float :offset-assert 1204) +; (~Tmoney int32 :offset-assert 1208) +; (~Tactivated basic :offset-assert 1212) +; ) +; :method-count-assert 29 +; :size-assert #x4c0 +; :flag-assert #x1d045004c0 +; ;; inherited inpspect of baseplat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; plat +; (deftype plat (baseplat) +; ((~Tpath-pos float :offset-assert 228) +; (~Tsync sync-info-eased :inline :offset-assert 232) +; (~Tsound-id uint32 :offset-assert 260) +; ) +; :method-count-assert 33 +; :size-assert #x108 +; :flag-assert #x2100a00108 +; ;; inherited inpspect of baseplat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; plat-button +; (deftype plat-button (process-drawable) +; ((~Tgo-back-if-lost-player? basic :offset-assert 176) +; (~Tgrab-player? basic :offset-assert 180) +; (~Tshould-grab-player? basic :offset-assert 184) +; (~Tpath-pos float :offset-assert 188) +; (~Tbidirectional? basic :offset-assert 192) +; (~Tallow-auto-kill basic :offset-assert 196) +; (~Tsound-id uint32 :offset-assert 200) +; (~Ttrans-off vector :inline :offset-assert 208) +; (~Tspawn-pos vector :inline :offset-assert 224) +; ) +; :method-count-assert 33 +; :size-assert #xf0 +; :flag-assert #x21008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; plat-eco +; (deftype plat-eco (plat) +; ((~Tnotice-dist float :offset-assert 264) +; (~Tsync-offset-dest float :offset-assert 268) +; (~Tsync-offset-faux float :offset-assert 272) +; (~Tsync-linear-val float :offset-assert 276) +; (~Ttarget uint64 :offset-assert 280) +; (~Tunlit-look lod-set :inline :offset-assert 288) +; (~Tlit-look lod-set :inline :offset-assert 324) +; ) +; :method-count-assert 33 +; :size-assert #x165 +; :flag-assert #x2101000165 +; ;; inherited inpspect of plat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; ropebridge +; (deftype ropebridge-tuning (structure) +; ((num-springs int32 :offset-assert 0) +; (num-spring-points int32 :offset-assert 4) +; (col-mesh-indexes uint32 :offset-assert 8) +; (view-frustum-radius float :offset-assert 12) +; (root-prim-radius float :offset-assert 16) +; (desired-spring-len float :offset-assert 20) +; (gravity float :offset-assert 24) +; (spring-coefficient float :offset-assert 28) +; (spring-mass float :offset-assert 32) +; (friction float :offset-assert 36) +; (max-influence-dist float :offset-assert 40) +; (rider-max-gravity float :offset-assert 44) +; (max-bonk-influence-dist float :offset-assert 48) +; (rider-bonk-force float :offset-assert 52) +; (rider-bonk-min float :offset-assert 56) +; (rider-bonk-max float :offset-assert 60) +; (normal-board-len float :offset-assert 64) +; (bridge-end-to-end-len float :offset-assert 68) +; (rest-state basic :offset-assert 72) +; ) +; :method-count-assert 9 +; :size-assert #x4c +; :flag-assert #x90000004c +; ) + +; ;; ropebridge +; (deftype ropebridge-spring-point (structure) +; ((local-pos vector :inline :offset-assert 0) +; (vel vector :inline :offset-assert 16) +; (extra-force vector :inline :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; ropebridge +; (deftype ropebridge (process-drawable) +; ((~Tsubtype uint64 :offset-assert 176) +; (~Tsubtype-name basic :offset-assert 184) +; (~Tagitated-time-stamp uint64 :offset-assert 192) +; (~Tbonk-time-stamp uint64 :offset-assert 200) +; (~Tattack-flop-time-stamp uint64 :offset-assert 208) +; (~Tplayer-attack-id uint64 :offset-assert 216) +; (~Tsleep-dist float :offset-assert 224) +; (~Tdo-physics? basic :offset-assert 228) +; (~Ttuning ropebridge-tuning :offset-assert 232) +; (~Tworld-matrix matrix :inline :offset-assert 240) +; (~Tinv-world-matrix matrix :inline :offset-assert 304) +; (~Textra-trans vector :inline :offset-assert 368) +; (~Tspring-point UNKNOWN 36 :offset-assert 384) +; ) +; :method-count-assert 29 +; :size-assert #x840 +; :flag-assert #x1d07d00840 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; ticky +; (deftype ticky (structure) +; ((delay-til-ramp uint64 :offset-assert 0) +; (delay-til-timeout uint64 :offset-assert 8) +; (starting-time uint64 :offset-assert 16) +; (last-tick-time uint64 :offset-assert 24) +; ) +; :method-count-assert 12 +; :size-assert #x20 +; :flag-assert #xc00000020 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; ) +; ) + +; ;; mistycannon +; (deftype angle-tracker (structure) +; ((value float :offset-assert 0) +; (min float :offset-assert 4) +; (range float :offset-assert 8) +; (speed float :offset-assert 12) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; mistycannon +; (deftype mistycannon-missile (process-drawable) +; ((~Tmuzzle-time float :offset-assert 176) +; (~Ttumble-quat quaternion :inline :offset-assert 192) +; (~Tblast-radius float :offset-assert 208) +; (~Twater-height float :offset-assert 212) +; (~Tsfx uint32 :offset-assert 216) +; (~Tpart2 basic :offset-assert 220) +; (~Tground-time uint64 :offset-assert 224) +; ) +; :method-count-assert 21 +; :size-assert #xe8 +; :flag-assert #x15008000e8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; mistycannon +; (deftype mistycannon-init-data (structure) +; ((pos vector :offset-assert 0) +; (vel vector :offset-assert 4) +; (rotate float :offset-assert 8) +; (flight-time float :offset-assert 12) +; (muzzle-time float :offset-assert 16) +; (blast-radius float :offset-assert 20) +; ) +; :method-count-assert 9 +; :size-assert #x18 +; :flag-assert #x900000018 +; ) + +; ;; mistycannon +; (deftype mistycannon (process-drawable) +; ((~Trotate angle-tracker :inline :offset-assert 176) +; (~Ttilt angle-tracker :inline :offset-assert 192) +; (~Tfront-wheel float :offset-assert 208) +; (~Trear-wheel float :offset-assert 212) +; (~Tlast-known-rotation float :offset-assert 216) +; (~Tpart-timer uint64 :offset-assert 224) +; (~Thellmouth vector :inline :offset-assert 240) +; (~Tpostbindinfo-ok basic :offset-assert 256) +; (~Tlaunch-origin vector :inline :offset-assert 272) +; (~Tgoggles vector :inline :offset-assert 288) +; (~Tavoid-entity basic :offset-assert 304) +; (~Tcenter-point vector :inline :offset-assert 320) +; (~Tat-point vector :inline :offset-assert 336) +; (~Taccuracy-range float :offset-assert 352) +; (~Ttarget-theta float :offset-assert 356) +; (~Tsound-id uint32 :offset-assert 360) +; (~Taim-sound-id uint32 :offset-assert 364) +; (~Tplayer-touching-grips? basic :offset-assert 368) +; ) +; :method-count-assert 24 +; :size-assert #x174 +; :flag-assert #x1801100174 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +; ;; mistycannon +; (deftype quadratic-solution (structure) +; ((s1 float :offset-assert 0) +; (s2 float :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; mistycannon +; (deftype trajectory-params (structure) +; ((x float :offset-assert 0) +; (y float :offset-assert 4) +; (gravity float :offset-assert 8) +; (theta float :offset-assert 12) +; (speed float :offset-assert 16) +; (time float :offset-assert 20) +; ) +; :method-count-assert 9 +; :size-assert #x18 +; :flag-assert #x900000018 +; ) + +; ;; babak-with-cannon +; (deftype babak-with-cannon (babak) +; ((~Tcannon-ent basic :offset-assert 400) +; (~Tdistance float :offset-assert 404) +; ) +; :method-count-assert 76 +; :size-assert #x198 +; :flag-assert #x4c01300198 +; ;; inherited inpspect of babak +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; air-h +; (deftype air-box (structure) +; ((vecs UNKNOWN 2 :offset-assert 0) +; (x-pos float :offset-assert 0) +; (height-level float :offset-assert 4) +; (z-pos float :offset-assert 8) +; (cos-angle float :offset-assert 12) +; (x-length float :offset-assert 16) +; (z-length float :offset-assert 24) +; (sin-angle float :offset-assert 28) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; wobbler +; (deftype wobbler (basic) +; ((posx float :offset-assert 4) +; (posy float :offset-assert 8) +; (velx float :offset-assert 12) +; (vely float :offset-assert 16) +; (spring float :offset-assert 20) +; (damping float :offset-assert 24) +; (height float :offset-assert 28) +; ) +; :method-count-assert 13 +; :size-assert #x20 +; :flag-assert #xd00000020 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; twister +; (deftype twist-joint (structure) +; ((ry float :offset-assert 0) +; (max-dry float :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; twister +; (deftype twister (basic) +; ((num-joints int32 :offset-assert 4) +; (first-joint int32 :offset-assert 8) +; (last-joint int32 :offset-assert 12) +; (max-speed float :offset-assert 16) +; (smoothing float :offset-assert 20) +; (min-dist float :offset-assert 24) +; (target float :offset-assert 28) +; (ry float :offset-assert 32) +; (max-speed-ry float :offset-assert 36) +; (data UNKNOWN :dynamic :offset-assert 40) +; ) +; :method-count-assert 13 +; :size-assert #x28 +; :flag-assert #xd00000028 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; beach-obs +; (deftype windmill-one (process-drawable) +; ((~Tsound-id uint32 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; beach-obs +; (deftype grottopole (process-drawable) +; ((~Tspeed meters :offset-assert 176) +; (~Tdistance meters :offset-assert 180) +; (~Tposition int32 :offset-assert 184) +; (~Tmax-position int32 :offset-assert 188) +; (~Tincomming-attack-id uint64 :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xc8 +; :flag-assert #x14006000c8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; beach-obs +; (deftype ecoventrock (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; beach-obs +; (deftype flying-rock (process-drawable) +; ((~Ttumble quaternion :inline :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xc0 +; :flag-assert #x14005000c0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; beach-obs +; (deftype bladeassm (process-drawable) +; ((~Tangle float :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; beach-obs +; (deftype flutflutegg (process-drawable) +; ((~Tfall-dist meters :offset-assert 176) +; (~Tstart vector :inline :offset-assert 192) +; (~Tdir vector :inline :offset-assert 208) +; (~Tpos float :offset-assert 224) +; (~Tvel float :offset-assert 228) +; (~Twobbler basic :offset-assert 232) +; (~Tlast-impulse-time int32 :offset-assert 236) +; (~Tincomming-attack-id uint64 :offset-assert 240) +; (~Tambients-played int32 :offset-assert 248) +; (~Tambient ambient-control :inline :offset-assert 256) +; ) +; :method-count-assert 21 +; :size-assert #x110 +; :flag-assert #x1500a00110 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; beach-obs +; (deftype harvester (process-drawable) +; ((~Talt-actor basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; beach-obs +; (deftype beachcam (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; bird-lady +; (deftype bird-lady (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; bird-lady-beach +; (deftype bird-lady-beach (process-taskable) +; ((~Tflutflut uint64 :offset-assert 384) +; (~Tegg uint64 :offset-assert 392) +; ) +; :method-count-assert 53 +; :size-assert #x190 +; :flag-assert #x3501200190 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; mayor +; (deftype mayor (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; sculptor +; (deftype sculptor (process-taskable) +; ((~Tmuse uint64 :offset-assert 384) +; ) +; :method-count-assert 53 +; :size-assert #x188 +; :flag-assert #x3501200188 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; pelican +; (deftype pelican-bank (basic) +; ((circle-speed meters :offset-assert 4) +; (dive-time useconds :offset-assert 8) +; (to-nest0-time useconds :offset-assert 16) +; (to-nest1-time useconds :offset-assert 24) +; (land-time useconds :offset-assert 32) +; (from-nest-time useconds :offset-assert 40) +; (spit-time useconds :offset-assert 48) +; (pre-spit-wait-time useconds :offset-assert 56) +; (post-spit-wait-time useconds :offset-assert 64) +; (run-away-time useconds :offset-assert 72) +; ) +; :method-count-assert 9 +; :size-assert #x50 +; :flag-assert #x900000050 +; ) + +; ;; pelican +; (deftype pelican (process-drawable) +; ((~Tquery gui-query :inline :offset-assert 176) +; (~Tfuel-cell uint64 :offset-assert 208) +; (~Tcam-tracker uint64 :offset-assert 216) +; (~Tpath-data UNKNOWN 8 :offset-assert 224) +; (~Tpath-circle basic :offset-assert 224) +; (~Tpath-dive0 basic :offset-assert 228) +; (~Tpath-to-nest0 basic :offset-assert 232) +; (~Tpath-from-nest0 basic :offset-assert 236) +; (~Tpath-spit0 basic :offset-assert 240) +; (~Tpath-dive1 basic :offset-assert 244) +; (~Tpath-to-nest1 basic :offset-assert 248) +; (~Tpath-to-nest2 basic :offset-assert 252) +; (~Tpath-cache basic :offset-assert 256) +; (~Ttime-cache uint64 :offset-assert 264) +; (~Tpath-pos float :offset-assert 272) +; (~Tpath-speed float :offset-assert 276) +; (~Tpath-max float :offset-assert 280) +; (~Tpath-vector vector :inline :offset-assert 288) +; (~Tstate-vector vector :inline :offset-assert 304) +; (~Tstate-vector1 vector :inline :offset-assert 320) +; (~Tstate-float UNKNOWN 2 :offset-assert 336) +; (~Tstate-object basic :offset-assert 344) +; (~Tneck basic :offset-assert 348) +; ) +; :method-count-assert 20 +; :size-assert #x160 +; :flag-assert #x1400f00160 +; ;; inherited inpspect of process-drawablefield ~Tstate-object is a basic loaded with a signed load +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lurkerworm +; (deftype lurkerworm (process-drawable) +; ((~Ttwister basic :offset-assert 176) +; (~Thead-tilt float :offset-assert 180) +; (~Tstrike-count int32 :offset-assert 184) +; (~Tangle float :offset-assert 188) +; (~Tvulnerable basic :offset-assert 192) +; (~Tpart2 basic :offset-assert 196) +; ) +; :method-count-assert 22 +; :size-assert #xc8 +; :flag-assert #x16006000c8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; lurkercrab +; (deftype lurkercrab (nav-enemy) +; ((~Torient basic :offset-assert 400) +; ) +; :method-count-assert 76 +; :size-assert #x194 +; :flag-assert #x4c01300194 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; lurkerpuppy +; (deftype lurkerpuppy (nav-enemy) +; () +; :method-count-assert 76 +; :size-assert #x190 +; :flag-assert #x4c01200190 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; beach-rocks +; (deftype beach-rock (process-drawable) +; ((~Ttrigger basic :offset-assert 176) +; (~Tmovie-start uint64 :offset-assert 184) +; (~Tpart-falling basic :offset-assert 192) +; (~Tpart-landing basic :offset-assert 196) +; (~Tprev-frame float :offset-assert 200) +; ) +; :method-count-assert 24 +; :size-assert #xcc +; :flag-assert #x18006000cc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +; ;; beach-rocks +; (deftype lrocklrg (beach-rock) +; () +; :method-count-assert 24 +; :size-assert #xcc +; :flag-assert #x18006000cc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +; ;; seagull +; (deftype seagull (process-drawable) +; ((~Tindex int32 :offset-assert 176) +; (~Tflock uint32 :offset-assert 180) +; (~Theading float :offset-assert 184) +; (~Ttilt float :offset-assert 188) +; (~Tmax-tilt float :offset-assert 192) +; (~Tangletan float :offset-assert 196) +; (~Ttarget-dist float :offset-assert 200) +; (~Tscared int32 :offset-assert 204) +; (~Ttemp-heading float :offset-assert 208) +; (~Ttemp-heading-time int32 :offset-assert 212) +; (~Tpart-time uint64 :offset-assert 216) +; (~Tthrust float :offset-assert 224) +; (~Tteleport basic :offset-assert 228) +; ) +; :method-count-assert 28 +; :size-assert #xe8 +; :flag-assert #x1c008000e8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + +; ;; seagull +; (deftype seagullflock (process) +; ((~Tpath basic :offset-assert 112) +; (~Ttrans vector :inline :offset-assert 128) +; (~Tbird UNKNOWN 64 :offset-assert 144) +; (~Tbirds int32 :offset-assert 400) +; (~Tlink basic :offset-assert 404) +; (~Tbird-at-waterfall uint64 :offset-assert 408) +; (~Tbirds-at-waterfall int32 :offset-assert 416) +; (~Ttarget vector :inline :offset-assert 432) +; (~Ttargetnum int32 :offset-assert 448) +; (~Talert-time uint64 :offset-assert 456) +; (~Tteleport-frames int32 :offset-assert 464) +; (~Tcam-tracker uint64 :offset-assert 472) +; (~Tstate-time uint64 :offset-assert 480) +; (~Tsquall basic :offset-assert 488) +; (~Tmax-lift float :offset-assert 492) +; ) +; :method-count-assert 17 +; :size-assert #x1f0 +; :flag-assert #x11018001f0 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; ) +; ) + +; ;; beach-part +; (deftype beach-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; villagep-obs +; (deftype warpgate (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; villagep-obs +; (deftype warp-gate-switch (basebutton) +; ((~Twarp uint64 :offset-assert 256) +; ) +; :method-count-assert 33 +; :size-assert #x108 +; :flag-assert #x2100a00108 +; ;; inherited inpspect of basebutton +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; villagep-obs +; (deftype village-cam (process) +; ((~Troot basic :offset-assert 112) +; (~Trange meters :offset-assert 116) +; (~Tindex int32 :offset-assert 120) +; (~Tstate-time uint64 :offset-assert 128) +; ) +; :method-count-assert 15 +; :size-assert #x88 +; :flag-assert #xf00200088 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; oracle +; (deftype oracle (process-taskable) +; ((~Tfirst-task uint8 :offset-assert 380) +; (~Tsecond-task uint8 :offset-assert 381) +; (~Tleft-eye-cell uint64 :offset-assert 384) +; (~Tright-eye-cell uint64 :offset-assert 392) +; ) +; :method-count-assert 53 +; :size-assert #x190 +; :flag-assert #x3501200190 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; battlecontroller +; (deftype battlecontroller-spawner (structure) +; ((path basic :offset-assert 0) +; (creature uint64 :offset-assert 8) +; (trigger-actor basic :offset-assert 16) +; (blocker-actor basic :offset-assert 20) +; (state int8 :offset-assert 24) +; (enabled basic :offset-assert 28) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; battlecontroller +; (deftype battlecontroller-creature-type (structure) +; ((type2 basic :offset-assert 0) +; (percent float :offset-assert 4) +; (pickup-percent float :offset-assert 8) +; (pickup-type int32 :offset-assert 12) +; (max-pickup-count int8 :offset-assert 16) +; (pickup-count int8 :offset-assert 17) +; ) +; :method-count-assert 9 +; :size-assert #x12 +; :flag-assert #x900000012 +; ) + +; ;; battlecontroller +; (deftype battlecontroller (process-drawable) +; ((~Tfinal-pickup-spawn-point vector :inline :offset-assert 176) +; (~Tactivate-distance float :offset-assert 192) +; (~Tmax-spawn-count int16 :offset-assert 196) +; (~Tspawn-count int16 :offset-assert 198) +; (~Tdie-count int16 :offset-assert 200) +; (~Ttarget-count int8 :offset-assert 202) +; (~Tspawner-count int8 :offset-assert 203) +; (~Tcreature-type-count int8 :offset-assert 204) +; (~Tspawner-array UNKNOWN 8 :offset-assert 208) +; (~Tspawn-period uint64 :offset-assert 464) +; (~Tpath-spawn basic :offset-assert 472) +; (~Tcreature-type-array UNKNOWN 4 :offset-assert 476) +; (~Tfinal-pickup-type int32 :offset-assert 604) +; (~Tprespawn basic :offset-assert 608) +; (~Tnoticed-player basic :offset-assert 612) +; (~Tcamera-on basic :offset-assert 616) +; (~Tmisty-ambush-collision-hack basic :offset-assert 620) +; (~Tdisable-ocean basic :offset-assert 624) +; (~Tdisable-near-ocean basic :offset-assert 628) +; (~Tdisable-mid-ocean basic :offset-assert 632) +; ) +; :method-count-assert 29 +; :size-assert #x27c +; :flag-assert #x1d0210027c +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; citadel-part +; (deftype citb-part (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; citadel-obs +; (deftype citb-arm-section (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Tcull-dir-local vector :inline :offset-assert 192) +; (~Tcull-dot float :offset-assert 208) +; (~Trot-scale float :offset-assert 212) +; (~Ty-angle float :offset-assert 216) +; ) +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-arm (citb-arm-section) +; () +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-arm-shoulder (citb-arm-section) +; () +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-arm-a (citb-arm) +; () +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-arm-b (citb-arm) +; () +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-arm-c (citb-arm) +; () +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-arm-d (citb-arm) +; () +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-arm-shoulder-a (citb-arm-shoulder) +; () +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-arm-shoulder-b (citb-arm-shoulder) +; () +; :method-count-assert 23 +; :size-assert #xdc +; :flag-assert #x17007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-disc (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Trot-scale float :offset-assert 184) +; ) +; :method-count-assert 22 +; :size-assert #xbc +; :flag-assert #x16005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-disc-a (citb-disc) +; () +; :method-count-assert 22 +; :size-assert #xbc +; :flag-assert #x16005000bc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-disc-b (citb-disc) +; () +; :method-count-assert 22 +; :size-assert #xbc +; :flag-assert #x16005000bc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-disc-c (citb-disc) +; () +; :method-count-assert 22 +; :size-assert #xbc +; :flag-assert #x16005000bc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-disc-d (citb-disc) +; () +; :method-count-assert 22 +; :size-assert #xbc +; :flag-assert #x16005000bc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-iris-door (eco-door) +; () +; :method-count-assert 27 +; :size-assert #x104 +; :flag-assert #x1b00a00104 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-button (basebutton) +; () +; :method-count-assert 32 +; :size-assert #x100 +; :flag-assert #x2000900100 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-launcher (plat) +; ((~Tlauncher uint32 :offset-assert 264) +; ) +; :method-count-assert 33 +; :size-assert #x10c +; :flag-assert #x2100a0010c +; ;; inherited inpspect of plat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-robotboss (process-drawable) +; ((~Tshield-on basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-coil (process-drawable) +; ((~Tpart-off basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-hose (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-chains (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-generator (process-drawable) +; ((~Tnormal-look lod-set :inline :offset-assert 176) +; (~Tbroken-look lod-set :inline :offset-assert 212) +; (~Tmushroom-pos vector :inline :offset-assert 256) +; (~Tmushroom basic :offset-assert 272) +; (~Tbirth-fuel-cell basic :offset-assert 276) +; (~Ttrigger-others basic :offset-assert 280) +; (~Tpart-broken basic :offset-assert 284) +; (~Tpart-mushroom basic :offset-assert 288) +; ) +; :method-count-assert 22 +; :size-assert #x124 +; :flag-assert #x1600c00124 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citadel-obs +; (deftype citadelcam (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; citadel-obs +; (deftype citb-battlecontroller (battlecontroller) +; () +; :method-count-assert 29 +; :size-assert #x27c +; :flag-assert #x1d0210027c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; citb-plat +; (deftype citb-base-plat (process-drawable) +; ((~Tidle-distance float :offset-assert 176) +; ) +; :method-count-assert 25 +; :size-assert #xb4 +; :flag-assert #x19005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; ) +; ) + +; ;; citb-plat +; (deftype citb-plat-eco (plat-eco) +; () +; :method-count-assert 33 +; :size-assert #x165 +; :flag-assert #x2101000165 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; citb-plat +; (deftype citb-plat (plat) +; ((~Ttrans-offset vector :inline :offset-assert 272) +; ) +; :method-count-assert 33 +; :size-assert #x120 +; :flag-assert #x2100b00120 +; ;; inherited inpspect of plat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; citb-plat +; (deftype citb-stair-plat (citb-base-plat) +; ((~Tidle-height float :offset-assert 180) +; (~Trise-height float :offset-assert 184) +; (~Tdelay uint64 :offset-assert 192) +; (~Trise basic :offset-assert 200) +; ) +; :method-count-assert 25 +; :size-assert #xcc +; :flag-assert #x19006000cc +; ;; inherited inpspect of citb-base-plat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; ) +; ) + +; ;; citb-plat +; (deftype citb-chain-plat (rigid-body-platform) +; ((~Torig-trans vector :inline :offset-assert 736) +; (~Torig-quat quaternion :inline :offset-assert 752) +; (~Tbeam-end vector :inline :offset-assert 768) +; (~Tfloat-offset float :offset-assert 784) +; (~Tidle-offset float :offset-assert 788) +; ) +; :method-count-assert 35 +; :size-assert #x318 +; :flag-assert #x2302b00318 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; citb-plat +; (deftype citb-rotatebox (citb-base-plat) +; () +; :method-count-assert 25 +; :size-assert #xb4 +; :flag-assert #x19005000b4 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; ) +; ) + +; ;; citb-plat +; (deftype citb-donut (citb-base-plat) +; ((~Tsync sync-info :inline :offset-assert 180) +; ) +; :method-count-assert 25 +; :size-assert #xbc +; :flag-assert #x19005000bc +; ;; inherited inpspect of citb-base-plat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; ) +; ) + +; ;; citb-plat +; (deftype citb-stopbox (plat) +; () +; :method-count-assert 33 +; :size-assert #x108 +; :flag-assert #x2100a00108 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; citb-plat +; (deftype citb-firehose (process-drawable) +; ((~Tidle-distance float :offset-assert 176) +; (~Tsync sync-info :inline :offset-assert 180) +; (~Tlast-sync float :offset-assert 188) +; (~Tblast-pos vector :inline :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xd0 +; :flag-assert #x14006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; citb-plat +; (deftype citb-exit-plat (plat-button) +; ((~Tidle-height float :offset-assert 240) +; (~Trise-height float :offset-assert 244) +; (~Tactivated basic :offset-assert 248) +; ) +; :method-count-assert 33 +; :size-assert #xfc +; :flag-assert #x21009000fc +; ;; inherited inpspect of plat-button +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; citadel-sages +; (deftype citb-sagecage (process-drawable) +; ((~Tbar-array UNKNOWN 12 :offset-assert 176) +; (~Tangle-offset float :offset-assert 368) +; (~Tbars-on basic :offset-assert 372) +; (~Tcloning basic :offset-assert 376) +; ) +; :method-count-assert 22 +; :size-assert #x17c +; :flag-assert #x160110017c +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citadel-sages +; (deftype citb-sage (process-taskable) +; ((~Tspawn-pos vector :inline :offset-assert 384) +; (~Ttarget-pos vector :inline :offset-assert 400) +; (~Tdir vector :inline :offset-assert 416) +; (~Trot-y float :offset-assert 432) +; (~Trot-x float :offset-assert 436) +; (~Tidle-anim int32 :offset-assert 440) +; (~Tattack-start-anim int32 :offset-assert 444) +; (~Tattack-anim int32 :offset-assert 448) +; (~Tbeam-joint int32 :offset-assert 452) +; (~Tcage uint64 :offset-assert 456) +; (~Tpart-impact basic :offset-assert 464) +; (~Tbeam-on basic :offset-assert 468) +; (~Tresolution-anim basic :offset-assert 472) +; (~Tsound-name basic :offset-assert 476) +; (~Tsound-id uint32 :offset-assert 480) +; (~Talt-actor basic :offset-assert 484) +; ) +; :method-count-assert 53 +; :size-assert #x1e8 +; :flag-assert #x35018001e8 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; citadel-sages +; (deftype red-sagecage (citb-sage) +; () +; :method-count-assert 53 +; :size-assert #x1e8 +; :flag-assert #x35018001e8 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; citadel-sages +; (deftype blue-sagecage (citb-sage) +; () +; :method-count-assert 53 +; :size-assert #x1e8 +; :flag-assert #x35018001e8 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; citadel-sages +; (deftype yellow-sagecage (citb-sage) +; () +; :method-count-assert 53 +; :size-assert #x1e8 +; :flag-assert #x35018001e8 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; citadel-sages +; (deftype green-sagecage (citb-sage) +; ((~Twhich-movie int32 :offset-assert 488) +; (~Tevilbro uint64 :offset-assert 496) +; (~Tevilsis uint64 :offset-assert 504) +; (~Trobotboss uint64 :offset-assert 512) +; (~Texitplat uint64 :offset-assert 520) +; ) +; :method-count-assert 53 +; :size-assert #x210 +; :flag-assert #x3501a00210 +; ;; inherited inpspect of citb-sage +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; snow-bunny +; (deftype snow-bunny (nav-enemy) +; ((~Tpatrol-rand-distraction int32 :offset-assert 400) +; (~Tbase-hop-dist float :offset-assert 404) +; (~Thalfway-dist float :offset-assert 408) +; (~Tretreat-timeout float :offset-assert 412) +; (~Tgnd-popup float :offset-assert 416) +; (~Tjump-height-min float :offset-assert 420) +; (~Tjump-height-factor float :offset-assert 424) +; (~Tjump-anim-start-frame float :offset-assert 428) +; (~Tdefense uint64 :offset-assert 432) +; (~Tretreat-timeout-time uint64 :offset-assert 440) +; (~Tlast-nondangerous-time uint64 :offset-assert 448) +; (~Tpatrol-hop-failed? basic :offset-assert 456) +; (~Tshould-retreat? basic :offset-assert 460) +; (~Tgot-jump-event? basic :offset-assert 464) +; (~Tusing-jump-event? basic :offset-assert 468) +; (~Tjump-anim int8 :offset-assert 472) +; (~Tnotice-land-anim int8 :offset-assert 473) +; (~Tattack-anim int8 :offset-assert 474) +; (~Tfinal-dest vector :inline :offset-assert 480) +; (~Tjump-event-dest vector :inline :offset-assert 496) +; ) +; :method-count-assert 77 +; :size-assert #x200 +; :flag-assert #x4d01900200 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; (dummy-76 () none 76) +; ) +; ) + +; ;; snow-bunny +; (deftype snow-bunny-retreat-work (structure) +; ((found-best basic :offset-assert 0) +; (using-jump-event? basic :offset-assert 4) +; (best-travel-dist float :offset-assert 8) +; (best-dest vector :inline :offset-assert 16) +; (away-vec vector :inline :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; citb-bunny +; (deftype citb-bunny (snow-bunny) +; () +; :method-count-assert 77 +; :size-assert #x200 +; :flag-assert #x4d01900200 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; (dummy-76 () none 76) +; ) +; ) + +; ;; citb-drop-plat-CIT +; (deftype drop-plat (process-drawable) +; ((~Tspin-axis vector :inline :offset-assert 176) +; (~Tspin-angle float :offset-assert 192) +; (~Tspin-speed float :offset-assert 196) +; (~Tinterp float :offset-assert 200) +; (~Tduration uint64 :offset-assert 208) +; (~Tdelay uint64 :offset-assert 216) +; (~Tcolor int8 :offset-assert 224) +; ) +; :method-count-assert 22 +; :size-assert #xe1 +; :flag-assert #x16008000e1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citb-drop-plat-CIT +; (deftype handle-inline-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; citb-drop-plat-CIT +; (deftype citb-drop-plat (process-drawable) +; ((~Tx-count int32 :offset-assert 176) +; (~Tz-count int32 :offset-assert 180) +; (~Tchild-count int32 :offset-assert 184) +; (~Tchild-array basic :offset-assert 188) +; (~Tchild-color-array uint32 :offset-assert 192) +; (~Tx-dir vector :inline :offset-assert 208) +; (~Tz-dir vector :inline :offset-assert 224) +; (~Torigin vector :inline :offset-assert 240) +; (~Tx-spacing float :offset-assert 256) +; (~Tz-spacing float :offset-assert 260) +; (~Tidle-distance float :offset-assert 264) +; (~Tduration uint64 :offset-assert 272) +; (~Tdrop-time uint64 :offset-assert 280) +; ) +; :method-count-assert 20 +; :size-assert #x120 +; :flag-assert #x1400b00120 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; citb-drop-plat-L1 +; (deftype drop-plat (process-drawable) +; ((~Tspin-axis vector :inline :offset-assert 176) +; (~Tspin-angle float :offset-assert 192) +; (~Tspin-speed float :offset-assert 196) +; (~Tinterp float :offset-assert 200) +; (~Tduration uint64 :offset-assert 208) +; (~Tdelay uint64 :offset-assert 216) +; (~Tcolor int8 :offset-assert 224) +; ) +; :method-count-assert 22 +; :size-assert #xe1 +; :flag-assert #x16008000e1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; citb-drop-plat-L1 +; (deftype handle-inline-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; citb-drop-plat-L1 +; (deftype citb-drop-plat (process-drawable) +; ((~Tx-count int32 :offset-assert 176) +; (~Tz-count int32 :offset-assert 180) +; (~Tchild-count int32 :offset-assert 184) +; (~Tchild-array basic :offset-assert 188) +; (~Tchild-color-array uint32 :offset-assert 192) +; (~Tx-dir vector :inline :offset-assert 208) +; (~Tz-dir vector :inline :offset-assert 224) +; (~Torigin vector :inline :offset-assert 240) +; (~Tx-spacing float :offset-assert 256) +; (~Tz-spacing float :offset-assert 260) +; (~Tidle-distance float :offset-assert 264) +; (~Tduration uint64 :offset-assert 272) +; (~Tdrop-time uint64 :offset-assert 280) +; ) +; :method-count-assert 20 +; :size-assert #x120 +; :flag-assert #x1400b00120 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; assistant-citadel +; (deftype assistant-lavatube-end (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; darkcave-obs +; (deftype cavecrystal (process-drawable) +; ((~Tis-master? basic :offset-assert 176) +; (~Tcrystal-id int32 :offset-assert 180) +; (~Tglow-u float :offset-assert 184) +; (~Tglow-wf-period int32 :offset-assert 188) +; (~Tglow-wf-offset int32 :offset-assert 192) +; (~Tprev-compute-glow-time uint64 :offset-assert 200) +; (~Tstart-fade-time uint64 :offset-assert 208) +; (~Tend-fade-time uint64 :offset-assert 216) +; (~Tactivated-time uint64 :offset-assert 224) +; (~Tlast-updated-user-lighting uint64 :offset-assert 232) +; (~Tplayer-attack-id uint64 :offset-assert 240) +; (~Ton-color-mult vector :inline :offset-assert 256) +; (~Ton-color-emissive vector :inline :offset-assert 272) +; (~Toff-color-mult vector :inline :offset-assert 288) +; (~Toff-color-emissive vector :inline :offset-assert 304) +; ) +; :method-count-assert 22 +; :size-assert #x140 +; :flag-assert #x1600d00140 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; static-screen +; (deftype static-screen (process) +; ((~Tpart UNKNOWN 1 :offset-assert 112) +; (~Tstate-time uint64 :offset-assert 120) +; ) +; :method-count-assert 15 +; :size-assert #x80 +; :flag-assert #xf00100080 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; robotboss-h +; (deftype robotboss-dda (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; robotboss-h +; (deftype robotboss (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; light-eco +; (deftype light-eco-child (process-drawable) +; ((~Tangle-bit int32 :offset-assert 176) +; (~Tground-y float :offset-assert 180) +; (~Tfalling-start-time uint64 :offset-assert 184) +; (~Tlast-update-time uint64 :offset-assert 192) +; (~Trot vector :inline :offset-assert 208) +; (~Trotv vector :inline :offset-assert 224) +; (~Ttraj trajectory :inline :offset-assert 240) +; ) +; :method-count-assert 21 +; :size-assert #x118 +; :flag-assert #x1500b00118 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; light-eco +; (deftype light-eco-mother (process-drawable) +; ((~Tplayer-got-eco? basic :offset-assert 176) +; (~Tangle-mask uint64 :offset-assert 184) +; (~Tdelay-til-spawn int32 :offset-assert 192) +; (~Tpart2 basic :offset-assert 196) +; (~Tlast-update-time uint64 :offset-assert 200) +; (~Tlast-spawned-time uint64 :offset-assert 208) +; ) +; :method-count-assert 22 +; :size-assert #xd8 +; :flag-assert #x16007000d8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; robotboss-weapon +; (deftype torus (structure) +; ((origin vector :inline :offset-assert 0) +; (axis vector :inline :offset-assert 16) +; (radius-primary float :offset-assert 32) +; (radius-secondary float :offset-assert 36) +; ) +; :method-count-assert 13 +; :size-assert #x28 +; :flag-assert #xd00000028 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; ) +; ) + +; ;; robotboss-weapon +; (deftype torus-verts (structure) +; ((vert UNKNOWN 8 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x80 +; :flag-assert #x900000080 +; ) + +; ;; robotboss-weapon +; (deftype arcing-shot (process-drawable) +; ((~Ty-vel float :offset-assert 176) +; (~Tgrav float :offset-assert 180) +; (~Tfrom vector :inline :offset-assert 192) +; (~Tto vector :inline :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xe0 +; :flag-assert #x14007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; robotboss-weapon +; (deftype darkecobomb (arcing-shot) +; ((~Tflight-time uint64 :offset-assert 224) +; (~Tcountdown-time float :offset-assert 232) +; (~Tanim-speed float :offset-assert 236) +; (~Tnext-tick float :offset-assert 240) +; ) +; :method-count-assert 20 +; :size-assert #xf4 +; :flag-assert #x14009000f4 +; ;; inherited inpspect of arcing-shot +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; robotboss-weapon +; (deftype greenshot (arcing-shot) +; ((~Tflight-time uint64 :offset-assert 224) +; ) +; :method-count-assert 20 +; :size-assert #xe8 +; :flag-assert #x14008000e8 +; ;; inherited inpspect of arcing-shot +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; robotboss-weapon +; (deftype redshot (arcing-shot) +; ((~Tflight-time uint64 :offset-assert 224) +; (~Tstall-time uint64 :offset-assert 232) +; (~Tring torus :inline :offset-assert 240) +; (~Trotation-offset uint64 :offset-assert 280) +; (~Tpart-track uint64 :offset-assert 288) +; (~Tshot-particle basic :offset-assert 296) +; (~Ttest-particle basic :offset-assert 300) +; ) +; :method-count-assert 20 +; :size-assert #x130 +; :flag-assert #x1400c00130 +; ;; inherited inpspect of arcing-shot +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; robotboss-weapon +; (deftype yellowshot (arcing-shot) +; ((~Tflight-time uint64 :offset-assert 224) +; ) +; :method-count-assert 20 +; :size-assert #xe8 +; :flag-assert #x14008000e8 +; ;; inherited inpspect of arcing-shot +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; robotboss-misc +; (deftype ecoclaw-part-info (structure) +; ((tracker uint64 :offset-assert 0) +; (kind basic :offset-assert 8) +; (trans vector :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; robotboss-misc +; (deftype ecoclaw (process-drawable) +; ((~Tparticles UNKNOWN 3 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #x110 +; :flag-assert #x1400a00110 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; robotboss-misc +; (deftype silodoor (process-drawable) +; ((~Tpart-opened float :offset-assert 176) +; ) +; :method-count-assert 22 +; :size-assert #xb4 +; :flag-assert #x16005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; robotboss-misc +; (deftype finalbosscam (process-taskable) +; ((~Trobotboss uint64 :offset-assert 384) +; ) +; :method-count-assert 53 +; :size-assert #x188 +; :flag-assert #x3501200188 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; green-eco-lurker +; (deftype green-eco-lurker (nav-enemy) +; ((~Tplayed-sound? basic :offset-assert 400) +; (~Tsound-delay int32 :offset-assert 404) +; (~Tappear-dest vector :inline :offset-assert 416) +; (~Ttraj trajectory :inline :offset-assert 432) +; ) +; :method-count-assert 76 +; :size-assert #x1d8 +; :flag-assert #x4c017001d8 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; green-eco-lurker +; (deftype green-eco-lurker-gen (process-drawable) +; ((~Tnum-to-spawn int32 :offset-assert 176) +; (~Tnum-spawned int32 :offset-assert 180) +; (~Tnum-alive int32 :offset-assert 184) +; ) +; :method-count-assert 20 +; :size-assert #xbc +; :flag-assert #x14005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; robotboss +; (deftype redshot-launch-info (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; robotboss +; (deftype redshot-launch-array (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; final-door +; (deftype fin-door (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; final-door +; (deftype final-door (process-drawable) +; () +; :method-count-assert 23 +; :size-assert #xb0 +; :flag-assert #x17004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; final-door +; (deftype power-left (final-door) +; () +; :method-count-assert 23 +; :size-assert #xb0 +; :flag-assert #x17004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; final-door +; (deftype power-right (final-door) +; () +; :method-count-assert 23 +; :size-assert #xb0 +; :flag-assert #x17004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; final-door +; (deftype powercellalt (process-drawable) +; ((~Tjump-pos vector :inline :offset-assert 176) +; (~Tbase vector :inline :offset-assert 192) +; (~Tindex int32 :offset-assert 208) +; ) +; :method-count-assert 23 +; :size-assert #xd4 +; :flag-assert #x17007000d4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; sage-finalboss-FIN +; (deftype plat-eco-finalboss (plat-eco) +; ((~Tforce-dest float :offset-assert 360) +; (~Ttarg-dest float :offset-assert 364) +; (~Tdest float :offset-assert 368) +; (~Tspeed float :offset-assert 372) +; (~Ttouch-time uint64 :offset-assert 376) +; ) +; :method-count-assert 33 +; :size-assert #x180 +; :flag-assert #x2101100180 +; ;; inherited inpspect of plat-eco +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; sage-finalboss-FIN +; (deftype sage-finalboss-particle (structure) +; ((part basic :offset-assert 0) +; (active basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; sage-finalboss-FIN +; (deftype sage-finalboss (process-taskable) +; ((~Tredsage uint64 :offset-assert 384) +; (~Tbluesage uint64 :offset-assert 392) +; (~Tyellowsage uint64 :offset-assert 400) +; (~Tassistant uint64 :offset-assert 408) +; (~Trobotplat uint64 :offset-assert 416) +; (~Trobotboss uint64 :offset-assert 424) +; (~Tsilodoor uint64 :offset-assert 432) +; (~Tjak-white uint64 :offset-assert 440) +; (~Tleft-door basic :offset-assert 448) +; (~Tright-door basic :offset-assert 452) +; (~Tkick-in-the-door basic :offset-assert 456) +; (~Tkick-the-credits basic :offset-assert 460) +; (~Tcredit-fade float :offset-assert 464) +; (~Tpalette-val float :offset-assert 468) +; (~Tparticle UNKNOWN 9 :offset-assert 472) +; (~Tparticle-whiteout basic :offset-assert 616) +; (~Tcredits-played basic :offset-assert 620) +; ) +; :method-count-assert 53 +; :size-assert #x270 +; :flag-assert #x3502000270 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; sage-finalboss-L1 +; (deftype plat-eco-finalboss (plat-eco) +; ((~Tforce-dest float :offset-assert 360) +; (~Ttarg-dest float :offset-assert 364) +; (~Tdest float :offset-assert 368) +; (~Tspeed float :offset-assert 372) +; (~Ttouch-time uint64 :offset-assert 376) +; ) +; :method-count-assert 33 +; :size-assert #x180 +; :flag-assert #x2101100180 +; ;; inherited inpspect of plat-eco +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; sage-finalboss-L1 +; (deftype sage-finalboss-particle (structure) +; ((part basic :offset-assert 0) +; (active basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; sage-finalboss-L1 +; (deftype sage-finalboss (process-taskable) +; ((~Tredsage uint64 :offset-assert 384) +; (~Tbluesage uint64 :offset-assert 392) +; (~Tyellowsage uint64 :offset-assert 400) +; (~Tassistant uint64 :offset-assert 408) +; (~Trobotplat uint64 :offset-assert 416) +; (~Trobotboss uint64 :offset-assert 424) +; (~Tsilodoor uint64 :offset-assert 432) +; (~Tjak-white uint64 :offset-assert 440) +; (~Tleft-door basic :offset-assert 448) +; (~Tright-door basic :offset-assert 452) +; (~Tkick-in-the-door basic :offset-assert 456) +; (~Tkick-the-credits basic :offset-assert 460) +; (~Tcredit-fade float :offset-assert 464) +; (~Tpalette-val float :offset-assert 468) +; (~Tparticle UNKNOWN 9 :offset-assert 472) +; (~Tparticle-whiteout basic :offset-assert 616) +; (~Tcredits-played basic :offset-assert 620) +; ) +; :method-count-assert 53 +; :size-assert #x270 +; :flag-assert #x3502000270 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; evilbro +; (deftype evilbro (process-taskable) +; ((~Tevilsis basic :offset-assert 380) +; ) +; :method-count-assert 53 +; :size-assert #x180 +; :flag-assert #x3501100180 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; evilbro +; (deftype evilsis (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; jungleb-obs +; (deftype eggtop (process-drawable) +; ((~Tcam-tracker uint64 :offset-assert 176) +; (~Tsound-id uint32 :offset-assert 184) +; ) +; :method-count-assert 20 +; :size-assert #xbc +; :flag-assert #x14005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungleb-obs +; (deftype jng-iris-door (eco-door) +; () +; :method-count-assert 27 +; :size-assert #x104 +; :flag-assert #x1b00a00104 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; plat-flip +; (deftype plat-flip (process-drawable) +; ((~Tpath-pos float :offset-assert 176) +; (~Tbefore-turn-down-time float :offset-assert 180) +; (~Tturn-down-time float :offset-assert 184) +; (~Tbefore-turn-up-time float :offset-assert 188) +; (~Tturn-up-time float :offset-assert 192) +; (~Ttotal-time float :offset-assert 196) +; (~Tsync sync-info :inline :offset-assert 200) +; (~Tbase-pos vector :inline :offset-assert 208) +; (~Tsmush smush-control :inline :offset-assert 224) +; ) +; :method-count-assert 20 +; :size-assert #x100 +; :flag-assert #x1400900100 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; aphid +; (deftype aphid (nav-enemy) +; ((~Ttry int32 :offset-assert 400) +; ) +; :method-count-assert 76 +; :size-assert #x194 +; :flag-assert #x4c01300194 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; plant-boss +; (deftype plant-boss (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; plant-boss +; (deftype plant-boss-arm (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; plant-boss +; (deftype plant-boss-leaf (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; jungle-elevator +; (deftype jungle-elevator (plat-button) +; ((~Tbottom-height float :offset-assert 240) +; (~Tteleport-if-below-y float :offset-assert 244) +; (~Tteleport-if-above-y float :offset-assert 248) +; ) +; :method-count-assert 33 +; :size-assert #xfc +; :flag-assert #x21009000fc +; ;; inherited inpspect of plat-button +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; bouncer +; (deftype springbox (process-drawable) +; ((~Tspring-height meters :offset-assert 176) +; (~Tsmush float :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; hopper +; (deftype hopper (nav-enemy) +; ((~Tjump-length float :offset-assert 400) +; (~Tshadow-min-y float :offset-assert 404) +; ) +; :method-count-assert 76 +; :size-assert #x198 +; :flag-assert #x4c01300198 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; junglesnake +; (deftype junglesnake-twist-joint (structure) +; ((joint-index int32 :offset-assert 0) +; (ry float :offset-assert 4) +; (drag-delta-ry float :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; junglesnake +; (deftype junglesnake-tilt-joint (structure) +; ((joint-index int32 :offset-assert 0) +; (flip-it basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; junglesnake +; (deftype junglesnake (process-drawable) +; ((~Tstate-time uint64 :offset-assert 168) +; (~Thit-player basic :offset-assert 184) +; (~Tis-lethal? basic :offset-assert 188) +; (~Trefractory-delay int32 :offset-assert 192) +; (~Try float :offset-assert 196) +; (~Tdes-ry float :offset-assert 200) +; (~Ttilt float :offset-assert 204) +; (~Tdes-tilt float :offset-assert 208) +; (~Ttrack-player-ry basic :offset-assert 212) +; (~Ttrack-player-tilt basic :offset-assert 216) +; (~Ttwist-joints UNKNOWN 24 :offset-assert 220) +; (~Ttilt-joints UNKNOWN 3 :offset-assert 604) +; ) +; :method-count-assert 25 +; :size-assert #x28c +; :flag-assert #x190220028c +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; ) +; ) + +; ;; darkvine +; (deftype darkvine (process-drawable) +; ((~Tspeed float :offset-assert 176) +; (~Ttip-index int8 :offset-assert 180) +; (~Tdangerous basic :offset-assert 184) +; (~Tvulnerable basic :offset-assert 188) +; (~Thit-player basic :offset-assert 192) +; (~Ttouch-time uint64 :offset-assert 200) +; (~Tplayer-attack-id int32 :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xd4 +; :flag-assert #x14007000d4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype logtrap (process-drawable) +; () +; :method-count-assert 21 +; :size-assert #xb0 +; :flag-assert #x15004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; jungle-obs +; (deftype towertop (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype lurkerm-tall-sail (process-drawable) +; ((~Tspeed float :offset-assert 176) +; (~Talt-actor basic :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype lurkerm-short-sail (process-drawable) +; ((~Tspeed float :offset-assert 176) +; (~Talt-actor basic :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype lurkerm-piston (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Tbase vector :inline :offset-assert 192) +; (~Theight vector :inline :offset-assert 208) +; (~Tspeed float :offset-assert 224) +; (~Talt-actor basic :offset-assert 228) +; ) +; :method-count-assert 20 +; :size-assert #xe8 +; :flag-assert #x14008000e8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype accordian (process-drawable) +; ((~Tspeed float :offset-assert 176) +; (~Talt-actor basic :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype junglecam (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; jungle-obs +; (deftype precurbridgecam (pov-camera) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; jungle-obs +; (deftype precurbridge-span (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ) + +; ;; jungle-obs +; (deftype precurbridge (process-drawable) +; ((~Tsmush smush-control :inline :offset-assert 176) +; (~Tbase vector :inline :offset-assert 208) +; (~Tactivation-point vector :inline :offset-assert 224) +; (~Tspan-array UNKNOWN 8 :offset-assert 240) +; ) +; :method-count-assert 20 +; :size-assert #x110 +; :flag-assert #x1400a00110 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype maindoor (process-drawable) +; ((~Tthresh vector :inline :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xc0 +; :flag-assert #x14005000c0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype sidedoor (eco-door) +; () +; :method-count-assert 27 +; :size-assert #x104 +; :flag-assert #x1b00a00104 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; jungle-obs +; (deftype jngpusher (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Tback-prim basic :offset-assert 184) +; ) +; :method-count-assert 20 +; :size-assert #xbc +; :flag-assert #x14005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-obs +; (deftype jungle-water (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; jungle-mirrors +; (deftype periscope (process-drawable) +; ((~Ty-offset meters :offset-assert 176) +; (~Ty-offset-grips meters :offset-assert 180) +; (~Theight meters :offset-assert 184) +; (~Tturn deg :offset-assert 188) +; (~Ttilt deg :offset-assert 192) +; (~Ttarget-turn deg :offset-assert 196) +; (~Ttarget-tilt deg :offset-assert 200) +; (~Tbase vector :inline :offset-assert 208) +; (~Treflector-trans vector :inline :offset-assert 224) +; (~Tnext-reflector-trans vector :inline :offset-assert 240) +; (~Tprev-reflector-trans vector :inline :offset-assert 256) +; (~Told-camera-matrix matrix :inline :offset-assert 272) +; (~Treflector uint32 :offset-assert 336) +; (~Tgauge-rot deg :offset-assert 340) +; (~Tlock-time uint64 :offset-assert 344) +; (~Taligned? basic :offset-assert 352) +; (~Traised? basic :offset-assert 356) +; (~Tplayer-touching-grips? basic :offset-assert 360) +; (~Tgrips-moving? basic :offset-assert 364) +; (~Tsound-id uint32 :offset-assert 368) +; (~Trise-sound-id uint32 :offset-assert 372) +; (~Tgrips-sound-id uint32 :offset-assert 376) +; (~Tgrips basic :offset-assert 380) +; (~Tpart-aligned basic :offset-assert 384) +; ) +; :method-count-assert 20 +; :size-assert #x184 +; :flag-assert #x1401200184 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-mirrors +; (deftype reflector (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-mirrors +; (deftype reflector-origin (process-drawable) +; ((~Treflector-trans vector :inline :offset-assert 176) +; (~Tnext-reflector-trans vector :inline :offset-assert 192) +; (~Treflector uint32 :offset-assert 208) +; (~Tnext basic :offset-assert 212) +; (~Tblocker basic :offset-assert 216) +; ) +; :method-count-assert 20 +; :size-assert #xdc +; :flag-assert #x14007000dc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-mirrors +; (deftype reflector-mirror (process-drawable) +; ((~Tbeam-end vector :inline :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xc0 +; :flag-assert #x14005000c0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; junglefish +; (deftype junglefish (nav-enemy) +; () +; :method-count-assert 76 +; :size-assert #x190 +; :flag-assert #x4c01200190 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; fisher-JUN +; (deftype fisher-bank (basic) +; ((width meters :offset-assert 4) +; (net-radius meters :offset-assert 8) +; (max-caught int32 :offset-assert 12) +; (max-missed int32 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; fisher-JUN +; (deftype fisher-params (structure) +; ((timeout uint64 :offset-assert 0) +; (vel float :offset-assert 8) +; (swing-min uint64 :offset-assert 16) +; (swing-max uint64 :offset-assert 24) +; (period uint64 :offset-assert 32) +; (fish-vel float :offset-assert 40) +; (bad-percent float :offset-assert 44) +; (deadly-percent float :offset-assert 48) +; (powerup-percent float :offset-assert 52) +; ) +; :method-count-assert 9 +; :size-assert #x38 +; :flag-assert #x900000038 +; ) + +; ;; fisher-JUN +; (deftype fisher (process-taskable) +; ((~Tpaddle-end UNKNOWN 2 :offset-assert 384) +; (~Tpaddle-pos vector :inline :offset-assert 416) +; (~Tpaddle float :offset-assert 432) +; (~Tpaddle-vel float :offset-assert 436) +; (~Tspawner float :offset-assert 440) +; (~Tspawner-last float :offset-assert 444) +; (~Tspawn-time uint64 :offset-assert 448) +; (~Tturn-time uint64 :offset-assert 456) +; (~Tswing-time uint64 :offset-assert 464) +; (~Tblock-time uint64 :offset-assert 472) +; (~Tblock int32 :offset-assert 480) +; (~Tcaught int32 :offset-assert 484) +; (~Tmissed int32 :offset-assert 488) +; (~Tdifficulty int32 :offset-assert 492) +; (~Tstart-time uint64 :offset-assert 496) +; (~Tambient-big-one uint64 :offset-assert 504) +; (~Tambient-steady uint64 :offset-assert 512) +; (~Tambient-sagging uint64 :offset-assert 520) +; (~Tambient-almost uint64 :offset-assert 528) +; (~Tcheat-temp int32 :offset-assert 536) +; (~Thard basic :offset-assert 540) +; (~Ttraining basic :offset-assert 544) +; (~Tparams fisher-params :inline :offset-assert 552) +; ) +; :method-count-assert 53 +; :size-assert #x260 +; :flag-assert #x3501f00260 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; fisher-JUN +; (deftype fisher-fish (process-drawable) +; ((~Tdir vector :inline :offset-assert 176) +; (~Toffset float :offset-assert 192) +; (~Tpos float :offset-assert 196) +; (~Tvel float :offset-assert 200) +; (~Tmode basic :offset-assert 204) +; (~Tsize meters :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xd4 +; :flag-assert #x14007000d4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; fisher-JUNGLE-L1 +; (deftype fisher-bank (basic) +; ((width meters :offset-assert 4) +; (net-radius meters :offset-assert 8) +; (max-caught int32 :offset-assert 12) +; (max-missed int32 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; fisher-JUNGLE-L1 +; (deftype fisher-params (structure) +; ((timeout uint64 :offset-assert 0) +; (vel float :offset-assert 8) +; (swing-min uint64 :offset-assert 16) +; (swing-max uint64 :offset-assert 24) +; (period uint64 :offset-assert 32) +; (fish-vel float :offset-assert 40) +; (bad-percent float :offset-assert 44) +; (deadly-percent float :offset-assert 48) +; (powerup-percent float :offset-assert 52) +; ) +; :method-count-assert 9 +; :size-assert #x38 +; :flag-assert #x900000038 +; ) + +; ;; fisher-JUNGLE-L1 +; (deftype fisher (process-taskable) +; ((~Tpaddle-end UNKNOWN 2 :offset-assert 384) +; (~Tpaddle-pos vector :inline :offset-assert 416) +; (~Tpaddle float :offset-assert 432) +; (~Tpaddle-vel float :offset-assert 436) +; (~Tspawner float :offset-assert 440) +; (~Tspawner-last float :offset-assert 444) +; (~Tspawn-time uint64 :offset-assert 448) +; (~Tturn-time uint64 :offset-assert 456) +; (~Tswing-time uint64 :offset-assert 464) +; (~Tblock-time uint64 :offset-assert 472) +; (~Tblock int32 :offset-assert 480) +; (~Tcaught int32 :offset-assert 484) +; (~Tmissed int32 :offset-assert 488) +; (~Tdifficulty int32 :offset-assert 492) +; (~Tstart-time uint64 :offset-assert 496) +; (~Tambient-big-one uint64 :offset-assert 504) +; (~Tambient-steady uint64 :offset-assert 512) +; (~Tambient-sagging uint64 :offset-assert 520) +; (~Tambient-almost uint64 :offset-assert 528) +; (~Tcheat-temp int32 :offset-assert 536) +; (~Thard basic :offset-assert 540) +; (~Ttraining basic :offset-assert 544) +; (~Tparams fisher-params :inline :offset-assert 552) +; ) +; :method-count-assert 53 +; :size-assert #x260 +; :flag-assert #x3501f00260 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; fisher-JUNGLE-L1 +; (deftype fisher-fish (process-drawable) +; ((~Tdir vector :inline :offset-assert 176) +; (~Toffset float :offset-assert 192) +; (~Tpos float :offset-assert 196) +; (~Tvel float :offset-assert 200) +; (~Tmode basic :offset-assert 204) +; (~Tsize meters :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xd4 +; :flag-assert #x14007000d4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; jungle-part +; (deftype jungle-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; launcherdoor +; (deftype launcherdoor (process-drawable) +; ((~Tnotify-player-passed-thru? basic :offset-assert 176) +; (~Tthresh-y float :offset-assert 180) +; (~Topen-speed float :offset-assert 184) +; (~Tclose-speed float :offset-assert 188) +; (~Tload-mode basic :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xc4 +; :flag-assert #x14006000c4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; target-racer-h-L1-RACERP +; (deftype racer-info (basic) +; ((entity basic :offset-assert 4) +; (bike-trans vector :inline :offset-assert 16) +; (bike-quat vector :inline :offset-assert 32) +; (bike-scale vector :inline :offset-assert 48) +; (mod-x float :offset-assert 64) +; (rot vector :inline :offset-assert 80) +; (rot-old vector :inline :offset-assert 96) +; (rotv vector :inline :offset-assert 112) +; (lean-rotx deg :offset-assert 128) +; (change-roty deg :offset-assert 132) +; (change-roty-old deg :offset-assert 136) +; (quat vector :inline :offset-assert 144) +; (surface-y meters :offset-assert 160) +; (surface-vy meters :offset-assert 164) +; (surface-quat vector :inline :offset-assert 176) +; (surface-quat-smooth vector :inline :offset-assert 192) +; (cushion-base meters :offset-assert 208) +; (cushion-offset meters :offset-assert 212) +; (cushion-bob meters :offset-assert 216) +; (cushion-bob-old meters :offset-assert 220) +; (cushion-smush smush-control :inline :offset-assert 224) +; (shock-offset meters :offset-assert 256) +; (shock-offsetv meters :offset-assert 260) +; (shock-rotx meters :offset-assert 264) +; (hill-value float :offset-assert 268) +; (hill-ground-value float :offset-assert 272) +; (hill-offset meters :offset-assert 276) +; (hill-rotx deg :offset-assert 280) +; (hill-boost meters :offset-assert 284) +; (bob-timer float :offset-assert 288) +; (bob-meta-timer float :offset-assert 292) +; (bob-meta-meta-timer float :offset-assert 296) +; (bob-mult-rot float :offset-assert 300) +; (bob-mult-trans float :offset-assert 304) +; (bob-period float :offset-assert 308) +; (bob-meta-time uint64 :offset-assert 312) +; (bob-hit-ground-time uint64 :offset-assert 320) +; (cur-rotx deg :offset-assert 328) +; (targ-rotx deg :offset-assert 332) +; (speed-rotx float :offset-assert 336) +; (mult-rotx deg :offset-assert 340) +; (front-blade basic :offset-assert 344) +; (front-rot deg :offset-assert 348) +; (front-rotv deg :offset-assert 352) +; (bottom-blade basic :offset-assert 356) +; (bottom-rot deg :offset-assert 360) +; (front basic :offset-assert 364) +; (front-turn deg :offset-assert 368) +; (tail basic :offset-assert 372) +; (tail-tilt deg :offset-assert 376) +; (transv-max meters :offset-assert 380) +; (slide-down-time UNKNOWN 2 :offset-assert 384) +; (slide-enter-time uint64 :offset-assert 400) +; (slide-mode int32 :offset-assert 408) +; (slide-amp float :offset-assert 412) +; (slide-grip-mult float :offset-assert 416) +; (slide-shift-x float :offset-assert 420) +; (slide-interp float :offset-assert 424) +; (heat float :offset-assert 428) +; (boost-time uint64 :offset-assert 432) +; (boost-duration uint64 :offset-assert 440) +; (boost-curve float :offset-assert 448) +; (boost-level float :offset-assert 452) +; (boost-target float :offset-assert 456) +; (boost-output float :offset-assert 460) +; (hop? basic :offset-assert 464) +; (hop-start-y float :offset-assert 468) +; (bounce int32 :offset-assert 472) +; (bounce-hit float :offset-assert 476) +; (engine-sound-id uint32 :offset-assert 480) +; (boost-sound-id uint32 :offset-assert 484) +; (engine-sound-pitch float :offset-assert 488) +; (turn-anim-targ float :offset-assert 492) +; (turn-anim-frame float :offset-assert 496) +; (turn-anim-vel float :offset-assert 500) +; (tail-anim-vel float :offset-assert 504) +; (tail-anim-frame float :offset-assert 508) +; (rudd-anim-vel float :offset-assert 512) +; (rudd-anim-frame float :offset-assert 516) +; (racing-time uint64 :offset-assert 520) +; (stick-lock basic :offset-assert 528) +; (stick-off basic :offset-assert 532) +; (heavy basic :offset-assert 536) +; (scrape-sound-id uint32 :offset-assert 540) +; (heat-sound-time uint64 :offset-assert 544) +; ) +; :method-count-assert 9 +; :size-assert #x238 +; :flag-assert #x900000238 +; ) + +; ;; target-racer-h-L1-RACERP +; (deftype racer-bank (basic) +; ((slide-hold-time useconds :offset-assert 8) +; (heat-max float :offset-assert 16) +; (hotcoals-heat-inc float :offset-assert 20) +; (lava-heat-inc float :offset-assert 24) +; (lava-air-heat-inc float :offset-assert 28) +; (surface-heat-inc float :offset-assert 32) +; (jump-heat-inc float :offset-assert 36) +; (lavatube-hotcoals-heat-inc float :offset-assert 40) +; (lavatube-lava-heat-inc float :offset-assert 44) +; (lavatube-lava-air-heat-inc float :offset-assert 48) +; (lavatube-surface-heat-inc float :offset-assert 52) +; (lavatube-jump-heat-inc float :offset-assert 56) +; (boost-curve-max meters :offset-assert 60) +; (boost-level-max meters :offset-assert 64) +; (boost-level-inc meters :offset-assert 68) +; (boost-duration useconds :offset-assert 72) +; (default-front-blade deg :offset-assert 80) +; (yellow-projectile-speed meters :offset-assert 84) +; ) +; :method-count-assert 9 +; :size-assert #x58 +; :flag-assert #x900000058 +; ) + +; ;; target-racer-h-FIC-LAV-MIS-OGR-ROL +; (deftype racer-info (basic) +; ((entity basic :offset-assert 4) +; (bike-trans vector :inline :offset-assert 16) +; (bike-quat vector :inline :offset-assert 32) +; (bike-scale vector :inline :offset-assert 48) +; (mod-x float :offset-assert 64) +; (rot vector :inline :offset-assert 80) +; (rot-old vector :inline :offset-assert 96) +; (rotv vector :inline :offset-assert 112) +; (lean-rotx deg :offset-assert 128) +; (change-roty deg :offset-assert 132) +; (change-roty-old deg :offset-assert 136) +; (quat vector :inline :offset-assert 144) +; (surface-y meters :offset-assert 160) +; (surface-vy meters :offset-assert 164) +; (surface-quat vector :inline :offset-assert 176) +; (surface-quat-smooth vector :inline :offset-assert 192) +; (cushion-base meters :offset-assert 208) +; (cushion-offset meters :offset-assert 212) +; (cushion-bob meters :offset-assert 216) +; (cushion-bob-old meters :offset-assert 220) +; (cushion-smush smush-control :inline :offset-assert 224) +; (shock-offset meters :offset-assert 256) +; (shock-offsetv meters :offset-assert 260) +; (shock-rotx meters :offset-assert 264) +; (hill-value float :offset-assert 268) +; (hill-ground-value float :offset-assert 272) +; (hill-offset meters :offset-assert 276) +; (hill-rotx deg :offset-assert 280) +; (hill-boost meters :offset-assert 284) +; (bob-timer float :offset-assert 288) +; (bob-meta-timer float :offset-assert 292) +; (bob-meta-meta-timer float :offset-assert 296) +; (bob-mult-rot float :offset-assert 300) +; (bob-mult-trans float :offset-assert 304) +; (bob-period float :offset-assert 308) +; (bob-meta-time uint64 :offset-assert 312) +; (bob-hit-ground-time uint64 :offset-assert 320) +; (cur-rotx deg :offset-assert 328) +; (targ-rotx deg :offset-assert 332) +; (speed-rotx float :offset-assert 336) +; (mult-rotx deg :offset-assert 340) +; (front-blade basic :offset-assert 344) +; (front-rot deg :offset-assert 348) +; (front-rotv deg :offset-assert 352) +; (bottom-blade basic :offset-assert 356) +; (bottom-rot deg :offset-assert 360) +; (front basic :offset-assert 364) +; (front-turn deg :offset-assert 368) +; (tail basic :offset-assert 372) +; (tail-tilt deg :offset-assert 376) +; (transv-max meters :offset-assert 380) +; (slide-down-time UNKNOWN 2 :offset-assert 384) +; (slide-enter-time uint64 :offset-assert 400) +; (slide-mode int32 :offset-assert 408) +; (slide-amp float :offset-assert 412) +; (slide-grip-mult float :offset-assert 416) +; (slide-shift-x float :offset-assert 420) +; (slide-interp float :offset-assert 424) +; (heat float :offset-assert 428) +; (boost-time uint64 :offset-assert 432) +; (boost-duration uint64 :offset-assert 440) +; (boost-curve float :offset-assert 448) +; (boost-level float :offset-assert 452) +; (boost-target float :offset-assert 456) +; (boost-output float :offset-assert 460) +; (hop? basic :offset-assert 464) +; (hop-start-y float :offset-assert 468) +; (bounce int32 :offset-assert 472) +; (bounce-hit float :offset-assert 476) +; (engine-sound-id uint32 :offset-assert 480) +; (boost-sound-id uint32 :offset-assert 484) +; (engine-sound-pitch float :offset-assert 488) +; (turn-anim-targ float :offset-assert 492) +; (turn-anim-frame float :offset-assert 496) +; (turn-anim-vel float :offset-assert 500) +; (tail-anim-vel float :offset-assert 504) +; (tail-anim-frame float :offset-assert 508) +; (rudd-anim-vel float :offset-assert 512) +; (rudd-anim-frame float :offset-assert 516) +; (racing-time uint64 :offset-assert 520) +; (stick-lock basic :offset-assert 528) +; (stick-off basic :offset-assert 532) +; (heavy basic :offset-assert 536) +; (unstuck-time uint64 :offset-assert 544) +; (stuck-count int32 :offset-assert 552) +; (scrape-sound-id uint32 :offset-assert 556) +; (heat-sound-time uint64 :offset-assert 560) +; ) +; :method-count-assert 9 +; :size-assert #x238 +; :flag-assert #x900000238 +; ) + +; ;; target-racer-h-FIC-LAV-MIS-OGR-ROL +; (deftype racer-bank (basic) +; ((slide-hold-time useconds :offset-assert 8) +; (heat-max float :offset-assert 16) +; (hotcoals-heat-inc float :offset-assert 20) +; (lava-heat-inc float :offset-assert 24) +; (lava-air-heat-inc float :offset-assert 28) +; (surface-heat-inc float :offset-assert 32) +; (jump-heat-inc float :offset-assert 36) +; (lavatube-hotcoals-heat-inc float :offset-assert 40) +; (lavatube-lava-heat-inc float :offset-assert 44) +; (lavatube-lava-air-heat-inc float :offset-assert 48) +; (lavatube-surface-heat-inc float :offset-assert 52) +; (lavatube-jump-heat-inc float :offset-assert 56) +; (boost-curve-max meters :offset-assert 60) +; (boost-level-max meters :offset-assert 64) +; (boost-level-inc meters :offset-assert 68) +; (boost-duration useconds :offset-assert 72) +; (default-front-blade deg :offset-assert 80) +; (yellow-projectile-speed meters :offset-assert 84) +; ) +; :method-count-assert 9 +; :size-assert #x58 +; :flag-assert #x900000058 +; ) + +; ;; racer-part +; (deftype hud-bike-heat (hud) +; () +; :method-count-assert 27 +; :size-assert #x118 +; :flag-assert #x1b00b00118 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; racer-part +; (deftype hud-bike-speed (hud) +; () +; :method-count-assert 27 +; :size-assert #x118 +; :flag-assert #x1b00b00118 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; racer +; (deftype racer (process-drawable) +; ((~Textra-trans vector :inline :offset-assert 176) +; (~Tcondition int32 :offset-assert 192) +; (~Tcell uint64 :offset-assert 200) +; (~Tpath-data UNKNOWN 2 :offset-assert 208) +; (~Tpath-target basic :offset-assert 208) +; (~Tpath-racer basic :offset-assert 212) +; (~Tauto-get-off basic :offset-assert 216) +; (~Tshadow-backup basic :offset-assert 220) +; ) +; :method-count-assert 24 +; :size-assert #xe0 +; :flag-assert #x18007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +; ;; blocking-plane +; (deftype blocking-plane (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; flutflut +; (deftype flutflut (process-drawable) +; ((~Textra-trans vector :inline :offset-assert 176) +; (~Tcondition int32 :offset-assert 192) +; (~Tauto-get-off basic :offset-assert 196) +; (~Tcell uint64 :offset-assert 200) +; (~Tpath-data UNKNOWN 2 :offset-assert 208) +; (~Tpath-target basic :offset-assert 208) +; (~Tpath-flut basic :offset-assert 212) +; (~Ttouch-time uint64 :offset-assert 216) +; ) +; :method-count-assert 24 +; :size-assert #xe0 +; :flag-assert #x18007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +; ;; target-flut +; (deftype flut-info (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; target-flut +; (deftype flut-bank (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; farmer +; (deftype farmer (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; explorer +; (deftype explorer (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; assistant +; (deftype assistant (process-taskable) +; ((~Tsound-id uint32 :offset-assert 380) +; ) +; :method-count-assert 53 +; :size-assert #x180 +; :flag-assert #x3501100180 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; sage +; (deftype sage (process-taskable) +; ((~Treminder-played basic :offset-assert 380) +; (~Tassistant uint64 :offset-assert 384) +; ) +; :method-count-assert 53 +; :size-assert #x188 +; :flag-assert #x3501200188 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; yakow +; (deftype yakow-bank (basic) +; ((walk-cycle-frame-count float :offset-assert 4) +; (run-cycle-frame-count float :offset-assert 8) +; (walk-speed meters :offset-assert 12) +; (run-speed meters :offset-assert 16) +; (walk-anim-speed float :offset-assert 20) +; (run-anim-speed float :offset-assert 24) +; (walk-away-dist meters :offset-assert 28) +; (run-away-dist meters :offset-assert 32) +; (walk-rotate-speed float :offset-assert 36) +; (run-rotate-speed float :offset-assert 40) +; (walk-turn-time uint64 :offset-assert 48) +; (run-turn-time uint64 :offset-assert 56) +; (max-walk-speed float :offset-assert 64) +; (min-run-speed float :offset-assert 68) +; (walk-run-blend-rate float :offset-assert 72) +; (walk-turn-blend-rate float :offset-assert 76) +; (max-run-speed float :offset-assert 80) +; (acceleration meters :offset-assert 84) +; (default-patrol-time uint64 :offset-assert 88) +; (default-idle-distance meters :offset-assert 96) +; (safe-distance meters :offset-assert 100) +; (min-run-anim-speed float :offset-assert 104) +; (max-run-anim-speed float :offset-assert 108) +; (min-walk-anim-speed float :offset-assert 112) +; (speed-boost-impulse meters :offset-assert 116) +; ) +; :method-count-assert 9 +; :size-assert #x78 +; :flag-assert #x900000078 +; ) + +; ;; yakow +; (deftype yakow (process-drawable) +; ((~Tplayer-attack-id int32 :offset-assert 176) +; (~Twalk-run-blend float :offset-assert 180) +; (~Twalk-turn-blend float :offset-assert 184) +; (~Trun-mode basic :offset-assert 188) +; (~Ttravel-speed meters :offset-assert 192) +; (~Tfinal-speed meters :offset-assert 196) +; (~Trotate-speed float :offset-assert 200) +; (~Tturn-time uint64 :offset-assert 208) +; (~Tvulnerable basic :offset-assert 216) +; (~Tgrazing basic :offset-assert 220) +; (~Tpush-velocity vector :inline :offset-assert 224) +; (~Thome-base vector :inline :offset-assert 240) +; (~Tdest-base vector :inline :offset-assert 256) +; (~Tdest-rot deg :offset-assert 272) +; (~Tenable-turn-around basic :offset-assert 276) +; (~Trotating basic :offset-assert 280) +; (~Tin-pen basic :offset-assert 284) +; ) +; :method-count-assert 20 +; :size-assert #x120 +; :flag-assert #x1400b00120 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype windmill-sail (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Tblade-normal vector :inline :offset-assert 192) +; (~Torig-quat quaternion :inline :offset-assert 208) +; (~Talt-actor basic :offset-assert 224) +; (~Tpart2 basic :offset-assert 228) +; ) +; :method-count-assert 20 +; :size-assert #xe8 +; :flag-assert #x14008000e8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype sagesail (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Tblade-normal vector :inline :offset-assert 192) +; (~Torig-quat quaternion :inline :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xe0 +; :flag-assert #x14007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype windspinner (process-drawable) +; ((~Tblade-normal vector :inline :offset-assert 176) +; (~Torig-quat quaternion :inline :offset-assert 192) +; (~Tangle float :offset-assert 208) +; (~Tangle-vel float :offset-assert 212) +; ) +; :method-count-assert 20 +; :size-assert #xd8 +; :flag-assert #x14007000d8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype mayorgears (process-drawable) +; ((~Talt-actor basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype reflector-middle (process-drawable) +; ((~Treflector-trans vector :inline :offset-assert 176) +; (~Tnext-reflector-trans vector :inline :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xd0 +; :flag-assert #x14006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype reflector-end (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype villa-starfish (process-drawable) +; ((~Tchild-count int8 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype starfish (nav-enemy) +; () +; :method-count-assert 76 +; :size-assert #x190 +; :flag-assert #x4c01200190 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; village-obs-L1 +; (deftype village-fish (process-drawable) +; ((~Tchild-count int8 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype villa-fisha (village-fish) +; () +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype villa-fishb (village-fish) +; () +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype cyclegen (structure) +; ((output float :offset-assert 0) +; (inc float :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; village-obs-L1 +; (deftype hutlamp (process-drawable) +; ((~Tpivot basic :offset-assert 176) +; (~Tclock cyclegen :inline :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xbc +; :flag-assert #x14005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-L1 +; (deftype revcycleprop (process-drawable) +; () +; :method-count-assert 21 +; :size-assert #xb0 +; :flag-assert #x15004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; village-obs-L1 +; (deftype revcycle (process-drawable) +; () +; :method-count-assert 21 +; :size-assert #xb0 +; :flag-assert #x15004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; village-obs-L1 +; (deftype villagea-water (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype windmill-sail (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Tblade-normal vector :inline :offset-assert 192) +; (~Torig-quat quaternion :inline :offset-assert 208) +; (~Talt-actor basic :offset-assert 224) +; (~Tpart2 basic :offset-assert 228) +; ) +; :method-count-assert 20 +; :size-assert #xe8 +; :flag-assert #x14008000e8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype sagesail (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Tblade-normal vector :inline :offset-assert 192) +; (~Torig-quat quaternion :inline :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xe0 +; :flag-assert #x14007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype windspinner (process-drawable) +; ((~Tblade-normal vector :inline :offset-assert 176) +; (~Torig-quat quaternion :inline :offset-assert 192) +; (~Tangle float :offset-assert 208) +; (~Tangle-vel float :offset-assert 212) +; ) +; :method-count-assert 20 +; :size-assert #xd8 +; :flag-assert #x14007000d8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype mayorgears (process-drawable) +; ((~Talt-actor basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype reflector-middle (process-drawable) +; ((~Treflector-trans vector :inline :offset-assert 176) +; (~Tnext-reflector-trans vector :inline :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xd0 +; :flag-assert #x14006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype reflector-end (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype villa-starfish (process-drawable) +; ((~Tchild-count int8 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype starfish (nav-enemy) +; () +; :method-count-assert 76 +; :size-assert #x190 +; :flag-assert #x4c01200190 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype village-fish (process-drawable) +; ((~Tchild-count int8 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype villa-fisha (village-fish) +; () +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype villa-fishb (village-fish) +; () +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype cyclegen (structure) +; ((output float :offset-assert 0) +; (inc float :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; village-obs-VI1 +; (deftype hutlamp (process-drawable) +; ((~Tpivot basic :offset-assert 176) +; (~Tclock cyclegen :inline :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xbc +; :flag-assert #x14005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype revcycleprop (process-drawable) +; () +; :method-count-assert 21 +; :size-assert #xb0 +; :flag-assert #x15004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype revcycle (process-drawable) +; () +; :method-count-assert 21 +; :size-assert #xb0 +; :flag-assert #x15004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; village-obs-VI1 +; (deftype villagea-water (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; fishermans-boat +; (deftype boat-stabilizer (structure) +; ((local-pos vector :inline :offset-assert 0) +; (normal vector :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; fishermans-boat +; (deftype vehicle-path (structure) +; ((point-array UNKNOWN 10 :offset-assert 0) +; (point-count int32 :offset-assert 160) +; ) +; :method-count-assert 14 +; :size-assert #xa4 +; :flag-assert #xe000000a4 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; fishermans-boat +; (deftype vehicle-controller (structure) +; ((path vehicle-path :offset-assert 0) +; (turning-radius-table uint32 :offset-assert 4) +; (throttle-control-table uint32 :offset-assert 8) +; (table-step float :offset-assert 12) +; (table-length int32 :offset-assert 16) +; (circle-radius float :offset-assert 20) +; (throttle float :offset-assert 24) +; (steering float :offset-assert 28) +; (path-dest-index int8 :offset-assert 32) +; (left-circle int8 :offset-assert 33) +; (path-dest-point vector :inline :offset-assert 48) +; (path-dest-velocity vector :inline :offset-assert 64) +; (dest-circle vector :inline :offset-assert 80) +; (target-point vector :inline :offset-assert 96) +; (sample-dir vector :inline :offset-assert 112) +; (sample-time uint64 :offset-assert 128) +; (sample-index int32 :offset-assert 136) +; ) +; :method-count-assert 17 +; :size-assert #x8c +; :flag-assert #x110000008c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; ) +; ) + +; ;; fishermans-boat +; (deftype fishermans-boat (rigid-body-platform) +; ((~Tstabilizer-array UNKNOWN 2 :offset-assert 736) +; (~Tengine-thrust-local-pos vector :inline :offset-assert 800) +; (~Tignition basic :offset-assert 816) +; (~Tengine-thrust float :offset-assert 820) +; (~Tpropeller basic :offset-assert 824) +; (~Tdock-point vector :inline :offset-assert 832) +; (~Tdest-dir vector :inline :offset-assert 848) +; (~Tdock-point-index int8 :offset-assert 864) +; (~Tauto-pilot basic :offset-assert 868) +; (~Tanchored basic :offset-assert 872) +; (~Twaiting-for-player basic :offset-assert 876) +; (~Tplayer-riding basic :offset-assert 880) +; (~Tboat-path vehicle-path :inline :offset-assert 896) +; (~Tcam-tracker uint64 :offset-assert 1064) +; (~Tplayer-attack-id int32 :offset-assert 696) +; (~Tkill-player basic :offset-assert 1076) +; (~Tengine-sound-id uint32 :offset-assert 1080) +; (~Tengine-sound-envelope float :offset-assert 1084) +; (~Tdebug-draw basic :offset-assert 1088) +; (~Tdebug-path-record basic :offset-assert 1092) +; (~Tdebug-path-playback basic :offset-assert 1096) +; (~Tmeasure-parameters basic :offset-assert 1100) +; (~Tcontroller vehicle-controller :inline :offset-assert 1104) +; (~Tanim basic :offset-assert 1244) +; (~Told-target-pos transformq :inline :offset-assert 1248) +; (~Tevilbro uint64 :offset-assert 1296) +; (~Tevilsis uint64 :offset-assert 1304) +; ) +; :method-count-assert 35 +; :size-assert #x520 +; :flag-assert #x2304b00520 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; village1-part +; (deftype villagea-part (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; sequence-a-village1 +; (deftype sequenceA-village1 (process-taskable) +; ((~Tboat uint64 :offset-assert 384) +; (~Tside uint64 :offset-assert 392) +; ) +; :method-count-assert 53 +; :size-assert #x190 +; :flag-assert #x3501200190 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; training-obs +; (deftype training-water (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; training-obs +; (deftype training-cam (process) +; ((~Troot basic :offset-assert 112) +; (~Trange meters :offset-assert 116) +; (~Tindex int32 :offset-assert 120) +; (~Tstate-time uint64 :offset-assert 128) +; ) +; :method-count-assert 15 +; :size-assert #x88 +; :flag-assert #xf00200088 +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; training-obs +; (deftype tra-pontoon (rigid-body-platform) +; ((~Tanchor-point vector :inline :offset-assert 736) +; ) +; :method-count-assert 35 +; :size-assert #x2f0 +; :flag-assert #x23028002f0 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; training-obs +; (deftype tra-iris-door (eco-door) +; () +; :method-count-assert 27 +; :size-assert #x104 +; :flag-assert #x1b00a00104 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; training-obs +; (deftype scarecrow-a (process-drawable) +; ((~Tincomming-attack-id uint64 :offset-assert 176) +; (~Tintersection vector :inline :offset-assert 192) +; ) +; :method-count-assert 22 +; :size-assert #xd0 +; :flag-assert #x16006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; training-obs +; (deftype scarecrow-b (process-drawable) +; ((~Tincomming-attack-id uint64 :offset-assert 176) +; (~Tintersection vector :inline :offset-assert 192) +; ) +; :method-count-assert 22 +; :size-assert #xd0 +; :flag-assert #x16006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; training-part +; (deftype training-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; misty-obs +; (deftype boatpaddle (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; misty-obs +; (deftype windturbine (process-drawable) +; ((~Tspawn-particle-enable basic :offset-assert 176) +; (~Tangle-speed float :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; misty-obs +; (deftype mis-bone-bridge (process-drawable) +; ((~Tparticle-group basic :offset-assert 176) +; (~Tplayer-attack-id int32 :offset-assert 180) +; (~Tfall-anim-index int32 :offset-assert 184) +; (~Thit-points int8 :offset-assert 188) +; ) +; :method-count-assert 20 +; :size-assert #xbd +; :flag-assert #x14005000bd +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; misty-obs +; (deftype breakaway (process-drawable) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; misty-obs +; (deftype breakaway-right (breakaway) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; misty-obs +; (deftype breakaway-mid (breakaway) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; misty-obs +; (deftype breakaway-left (breakaway) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; misty-obs +; (deftype bone-platform (rigid-body-platform) +; ((~Tanchor-point vector :inline :offset-assert 736) +; ) +; :method-count-assert 35 +; :size-assert #x2f0 +; :flag-assert #x23028002f0 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; misty-obs +; (deftype mistycam (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; misty-obs +; (deftype misty-battlecontroller (battlecontroller) +; () +; :method-count-assert 29 +; :size-assert #x27c +; :flag-assert #x1d0210027c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; misty-obs +; (deftype boat-fuelcell (process-drawable) +; ((~Tplay-cutscene? basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; misty-warehouse +; (deftype silostep (process-drawable) +; ((~Tanim-limit float :offset-assert 176) +; (~Tcam-tracker uint64 :offset-assert 184) +; ) +; :method-count-assert 20 +; :size-assert #xc0 +; :flag-assert #x14005000c0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; misty-warehouse +; (deftype rounddoor (eco-door) +; () +; :method-count-assert 27 +; :size-assert #x104 +; :flag-assert #x1b00a00104 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; misty-conveyor +; (deftype keg-conveyor (process-drawable) +; ((~Tpivot basic :offset-assert 176) +; (~Tquat quaternion :inline :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xd0 +; :flag-assert #x14006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; misty-conveyor +; (deftype keg-conveyor-paddle (process-drawable) +; ((~Tobject-on-paddle uint32 :offset-assert 176) +; (~Tsync sync-info :inline :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xbc +; :flag-assert #x14005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; misty-conveyor +; (deftype keg (process-drawable) +; ((~Tsync-offset float :offset-assert 176) +; (~Tkeg-behavior int8 :offset-assert 180) +; (~Tpath-position vector :inline :offset-assert 192) +; (~Tshadow-enable-plane vector :inline :offset-assert 208) +; (~Tsmush smush-control :inline :offset-assert 224) +; (~Tsound-id uint32 :offset-assert 256) +; ) +; :method-count-assert 20 +; :size-assert #x104 +; :flag-assert #x1400a00104 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; mud +; (deftype mud (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; muse +; (deftype muse (nav-enemy) +; ((~Tcurrent-path-index float :offset-assert 400) +; (~Tprev-path-index float :offset-assert 404) +; (~Tdest-path-index float :offset-assert 408) +; (~Tplayer-path-index float :offset-assert 412) +; (~Tmax-path-index float :offset-assert 416) +; (~Tsprint-distance float :offset-assert 420) +; (~Tdest-point vector :inline :offset-assert 432) +; (~Tanim basic :offset-assert 448) +; (~Tvictory-anim basic :offset-assert 452) +; (~Told-target-pos transformq :inline :offset-assert 464) +; ) +; :method-count-assert 76 +; :size-assert #x200 +; :flag-assert #x4c01900200 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; muse +; (deftype point-on-path-segment-info (structure) +; ((point vector :inline :offset-assert 0) +; (segment UNKNOWN 2 :offset-assert 16) +; (dir vector :inline :offset-assert 48) +; (nearest-point vector :inline :offset-assert 64) +; (segment-length float :offset-assert 80) +; (distance-to-segment float :offset-assert 84) +; (parametric-index float :offset-assert 88) +; ) +; :method-count-assert 9 +; :size-assert #x5c +; :flag-assert #x90000005c +; ) + +; ;; bonelurker +; (deftype bonelurker (nav-enemy) +; ((~Tbump-player-time uint64 :offset-assert 400) +; ) +; :method-count-assert 76 +; :size-assert #x198 +; :flag-assert #x4c01300198 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; quicksandlurker +; (deftype quicksandlurker-missile (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; quicksandlurker +; (deftype quicksandlurker-missile-init-data (structure) +; ((position vector :offset-assert 0) +; (velocity vector :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; quicksandlurker +; (deftype quicksandlurker (process-drawable) +; ((~Toriginal-position vector :inline :offset-assert 176) +; (~Ty-offset float :offset-assert 192) +; (~Ttheta-angle float :offset-assert 196) +; (~Tradial-offset float :offset-assert 200) +; (~Tbob-angle float :offset-assert 204) +; (~Tmud-entity basic :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xd4 +; :flag-assert #x14007000d4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; misty-teetertotter +; (deftype teetertotter (process-drawable) +; ((~Tlaunched-player basic :offset-assert 176) +; (~Tin-launch-window basic :offset-assert 180) +; (~Trock-is-dangerous basic :offset-assert 184) +; ) +; :method-count-assert 20 +; :size-assert #xbc +; :flag-assert #x14005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; balloonlurker +; (deftype balloonlurker-bank (basic) +; ((buoyancy-depth-offset meters :offset-assert 4) +; (player-mass float :offset-assert 8) +; (rudder-factor float :offset-assert 12) +; (max-engine-thrust float :offset-assert 16) +; (max-rudder-deflection-angle float :offset-assert 20) +; (throttle-factor float :offset-assert 24) +; (throttle-distance float :offset-assert 28) +; (throttle-close-distance float :offset-assert 32) +; (explosion-force float :offset-assert 36) +; (mine-weight float :offset-assert 40) +; ) +; :method-count-assert 9 +; :size-assert #x2c +; :flag-assert #x90000002c +; ) + +; ;; balloonlurker +; (deftype balloonlurker (rigid-body-platform) +; ((~Texplosion-force-position vector :inline :offset-assert 736) +; (~Texplosion-force vector :inline :offset-assert 752) +; (~Texplosion basic :offset-assert 768) +; (~Texplosion-joint-index UNKNOWN 2 :offset-assert 772) +; (~Tvulnerable basic :offset-assert 776) +; (~Twater-y float :offset-assert 780) +; (~Tpropeller basic :offset-assert 784) +; (~Trudder basic :offset-assert 788) +; (~Tmine UNKNOWN 2 :offset-assert 792) +; (~Tbuoyancy-factor float :offset-assert 800) +; (~Trudder-control float :offset-assert 804) +; (~Tthrottle-control float :offset-assert 808) +; (~Tengine-thrust float :offset-assert 812) +; (~Tdest-point vector :inline :offset-assert 816) +; (~Tdest-point-old vector :inline :offset-assert 832) +; (~Tdest-index int8 :offset-assert 848) +; (~Tauto-pilot basic :offset-assert 852) +; (~Tdead basic :offset-assert 856) +; (~Tanim-frame float :offset-assert 860) +; (~Tengine-sound-id uint32 :offset-assert 864) +; (~Tpedal-sound-id uint32 :offset-assert 868) +; (~Tframe-count int8 :offset-assert 872) +; ) +; :method-count-assert 35 +; :size-assert #x369 +; :flag-assert #x2303000369 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; balloonlurker +; (deftype balloonlurker-pilot (process-drawable) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; misty-part +; (deftype misty-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; sidekick-human +; (deftype sequenceA (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; sidekick-human +; (deftype sequenceB (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-taskable) parent was UNKNOWN +; ) + +; ;; sidekick-human +; (deftype sequenceC (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-taskable) parent was UNKNOWN +; ) + +; ;; sidekick-human +; (deftype army-info (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; firecanyon-part +; (deftype firecanyon-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; assistant-firecanyon +; (deftype assistant-firecanyon (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; village2-part +; (deftype villageb-part (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; village2-obs +; (deftype village2cam (pov-camera) +; ((~Tseq uint64 :offset-assert 224) +; ) +; :method-count-assert 30 +; :size-assert #xe8 +; :flag-assert #x1e008000e8 +; ;; inherited inpspect of pov-camera +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; village2-obs +; (deftype pontoon (rigid-body-platform) +; ((~Tanchor-point vector :inline :offset-assert 736) +; (~Ttask uint8 :offset-assert 752) +; (~Talt-task uint8 :offset-assert 753) +; ) +; :method-count-assert 35 +; :size-assert #x2f2 +; :flag-assert #x23029002f2 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; village2-obs +; (deftype pontoonfive (pontoon) +; () +; :method-count-assert 35 +; :size-assert #x2f2 +; :flag-assert #x23029002f2 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; village2-obs +; (deftype pontoonten (pontoon) +; () +; :method-count-assert 35 +; :size-assert #x2f2 +; :flag-assert #x23029002f2 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; village2-obs +; (deftype allpontoons (process-drawable) +; ((~Ttask uint8 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb1 +; :flag-assert #x14005000b1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village2-obs +; (deftype fireboulder (process-drawable) +; ((~Ttracker uint64 :offset-assert 176) +; (~Ttask uint8 :offset-assert 184) +; ) +; :method-count-assert 20 +; :size-assert #xb9 +; :flag-assert #x14005000b9 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village2-obs +; (deftype ceilingflag (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village2-obs +; (deftype exit-chamber-dummy (process-drawable) +; ((~Torig-trans vector :inline :offset-assert 176) +; (~Tfcell-handle uint64 :offset-assert 192) +; ) +; :method-count-assert 21 +; :size-assert #xc8 +; :flag-assert #x15006000c8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; village2-obs +; (deftype ogreboss-village2 (process-drawable) +; ((~Tboulder uint64 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village2-obs +; (deftype villageb-ogreboss (ogreboss-village2) +; () +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; village2-obs +; (deftype villageb-water (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; gambler +; (deftype gambler (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; warrior +; (deftype warrior (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; geologist +; (deftype geologist (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; swamp-blimp +; (deftype swamp-blimp-bank (basic) +; ((arm-index int32 :offset-assert 4) +; (pause-before-dropping-arm int32 :offset-assert 8) +; (rise-per-break float :offset-assert 12) +; (arm-sink-wait float :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; swamp-blimp +; (deftype tetherrock-info (structure) +; ((rock-camera basic :offset-assert 0) +; (arm-camera basic :offset-assert 4) +; (blimp-rp int32 :offset-assert 8) +; (other-rp int32 :offset-assert 12) +; (connected-to-rock basic :offset-assert 16) +; (damping float :offset-assert 20) +; ) +; :method-count-assert 9 +; :size-assert #x18 +; :flag-assert #x900000018 +; ) + +; ;; swamp-blimp +; (deftype swamp-rope-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) +; (value float :offset-assert 16) +; ) +; :method-count-assert 11 +; :size-assert #x14 +; :flag-assert #xb00000014 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; swamp-blimp +; (deftype swamp-rope-oscillator (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) +; (damping float :offset-assert 20) +; ) +; :method-count-assert 11 +; :size-assert #x18 +; :flag-assert #xb00000018 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; swamp-blimp +; (deftype swamp-blimp-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) +; (value vector :inline :offset-assert 32) +; ) +; :method-count-assert 11 +; :size-assert #x30 +; :flag-assert #xb00000030 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; swamp-blimp +; (deftype swamp-blimp-oscillator (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) +; (damping float :offset-assert 56) +; ) +; :method-count-assert 11 +; :size-assert #x3c +; :flag-assert #xb0000003c +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; swamp-blimp +; (deftype swamp-tetherrock (process-drawable) +; ((~Ttension float :offset-assert 176) +; (~Ttension-pt vector :inline :offset-assert 192) +; (~Tblimp basic :offset-assert 208) +; (~Trot-at-init quaternion :inline :offset-assert 224) +; (~Thits int32 :offset-assert 240) +; ) +; :method-count-assert 20 +; :size-assert #xf4 +; :flag-assert #x14009000f4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; swamp-blimp +; (deftype precursor-arm (process-drawable) +; ((~Ty-init float :offset-assert 176) +; (~Ty-offset float :offset-assert 180) +; (~Trot-speed float :offset-assert 184) +; (~Trot-dist float :offset-assert 188) +; (~Trot-base float :offset-assert 192) +; (~Trot-t float :offset-assert 196) +; (~Tinit-mat matrix :inline :offset-assert 208) +; (~Ttension float :offset-assert 272) +; ) +; :method-count-assert 20 +; :size-assert #x114 +; :flag-assert #x1400b00114 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; swamp-blimp +; (deftype swamp-rope (process-drawable) +; ((~Tparent-rp int32 :offset-assert 176) +; (~Tother-entity basic :offset-assert 180) +; (~Tother-rp int32 :offset-assert 184) +; (~Told-scale float :offset-assert 188) +; (~Tframe swamp-rope-oscillator :inline :offset-assert 192) +; (~Tother-pos vector :inline :offset-assert 224) +; (~Tscale-base float :offset-assert 240) +; (~Tbase-vec vector :inline :offset-assert 256) +; (~Tscale-t float :offset-assert 272) +; (~Tx-t float :offset-assert 276) +; (~Tz-t float :offset-assert 280) +; (~Trot-speed float :offset-assert 284) +; ) +; :method-count-assert 21 +; :size-assert #x120 +; :flag-assert #x1500b00120 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; swamp-blimp +; (deftype swamp-blimp (process-drawable) +; ((~Tthe-ropes UNKNOWN 5 :offset-assert 176) +; (~Tarm-timer int32 :offset-assert 216) +; (~Ttrans-at-init vector :inline :offset-assert 224) +; (~Trot-at-init quaternion :inline :offset-assert 240) +; (~Ty-vel float :offset-assert 256) +; (~Ty-offset float :offset-assert 260) +; (~Ty-offset-target float :offset-assert 264) +; (~Tmain-tilt-rand swamp-blimp-rand-vector :inline :offset-assert 272) +; (~Tmain-tilt-oscillator swamp-blimp-oscillator :inline :offset-assert 320) +; (~Tgondola-tilt-oscillator swamp-blimp-oscillator :inline :offset-assert 384) +; (~Tpos-rand swamp-blimp-rand-vector :inline :offset-assert 448) +; (~Tpos-oscillator swamp-blimp-oscillator :inline :offset-assert 496) +; (~Tscale-rand swamp-rope-rand-float :inline :offset-assert 556) +; (~Tscale-oscillator swamp-rope-oscillator :inline :offset-assert 576) +; (~Tgondola basic :offset-assert 600) +; (~Tbag basic :offset-assert 604) +; ) +; :method-count-assert 20 +; :size-assert #x260 +; :flag-assert #x1401f00260 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; sage-bluehut +; (deftype assistant-bluehut (process-taskable) +; ((~Tsound-id uint32 :offset-assert 380) +; (~Tjaws uint64 :offset-assert 384) +; (~Tsage basic :offset-assert 392) +; (~Tim-talking basic :offset-assert 396) +; ) +; :method-count-assert 53 +; :size-assert #x190 +; :flag-assert #x3501200190 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; sage-bluehut +; (deftype sage-bluehut (process-taskable) +; ((~Treminder-played basic :offset-assert 380) +; (~Tassistant basic :offset-assert 384) +; ) +; :method-count-assert 53 +; :size-assert #x184 +; :flag-assert #x3501200184 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; flutflut-bluehut +; (deftype flutflut-bluehut (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; assistant-village2 +; (deftype assistant-levitator (process-taskable) +; ((~Tboulder basic :offset-assert 380) +; (~Tparticle UNKNOWN 4 :offset-assert 384) +; ) +; :method-count-assert 53 +; :size-assert #x190 +; :flag-assert #x3501200190 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; sunken-elevator +; (deftype sunken-elevator (plat-button) +; ((~Tplay-at-top-going-up-camera? basic :offset-assert 240) +; (~Tteleport-if-below-y float :offset-assert 244) +; (~Tteleport-if-above-y float :offset-assert 248) +; ) +; :method-count-assert 33 +; :size-assert #xfc +; :flag-assert #x21009000fc +; ;; inherited inpspect of plat-button +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; swamp-obs +; (deftype swamp-spike (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Topen-gate basic :offset-assert 184) +; (~Tdangerous basic :offset-assert 188) +; ) +; :method-count-assert 21 +; :size-assert #xc0 +; :flag-assert #x15005000c0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; swamp-obs +; (deftype swampgate (swamp-spike) +; () +; :method-count-assert 21 +; :size-assert #xc0 +; :flag-assert #x15005000c0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; swamp-obs +; (deftype balance-plat (process-drawable) +; ((~Ty-travel float :offset-assert 176) +; (~Ty-init float :offset-assert 180) +; (~Ty-offset float :offset-assert 184) +; (~Ty-vel float :offset-assert 188) +; (~Ty-accel float :offset-assert 192) +; (~Tgot-grow basic :offset-assert 196) +; ) +; :method-count-assert 20 +; :size-assert #xc8 +; :flag-assert #x14006000c8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; swamp-obs +; (deftype swamp-rock (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; swamp-obs +; (deftype tar-plat (rigid-body-platform) +; ((~Tanchor-point vector :inline :offset-assert 736) +; (~Tfloat-height float :offset-assert 752) +; ) +; :method-count-assert 35 +; :size-assert #x2f4 +; :flag-assert #x23029002f4 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; swamp-obs +; (deftype swamp-barrel (barrel) +; () +; :method-count-assert 30 +; :size-assert #x100 +; :flag-assert #x1e00900100 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; swamp-obs +; (deftype swampcam (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; swamp-obs +; (deftype swamp-battlecontroller (battlecontroller) +; () +; :method-count-assert 29 +; :size-assert #x27c +; :flag-assert #x1d0210027c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; swamp-bat +; (deftype swamp-bat-idle-path (structure) +; ((origin vector :inline :offset-assert 0) +; (x-axis vector :inline :offset-assert 16) +; (y-axis vector :inline :offset-assert 32) +; ) +; :method-count-assert 10 +; :size-assert #x30 +; :flag-assert #xa00000030 +; (:methods +; (dummy-9 () none 9) +; ) +; ) + +; ;; swamp-bat +; (deftype swamp-bat (process-drawable) +; ((~Tpath-origin vector :inline :offset-assert 176) +; (~Tidle-position-angle UNKNOWN 8 :offset-assert 192) +; (~Tpath-select-plane UNKNOWN 2 :offset-assert 224) +; (~Tpath-list UNKNOWN 2 :offset-assert 256) +; (~Tpath-select int8 :offset-assert 264) +; (~Tslave-count int8 :offset-assert 265) +; (~Tpath-count int8 :offset-assert 266) +; ) +; :method-count-assert 20 +; :size-assert #x10b +; :flag-assert #x1400a0010b +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; swamp-bat +; (deftype swamp-bat-slave (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; (~Tidle-anim-speed float :offset-assert 184) +; (~Tstrafe-envelope float :offset-assert 188) +; (~Tstrafe-distance float :offset-assert 192) +; (~Tpath-point-count float :offset-assert 196) +; (~Tidle-path swamp-bat-idle-path :inline :offset-assert 208) +; (~Tidle-position vector :inline :offset-assert 256) +; (~Tidle-position-index int8 :offset-assert 272) +; (~Tpath-select int8 :offset-assert 273) +; (~Tlaunch-ready basic :offset-assert 276) +; ) +; :method-count-assert 21 +; :size-assert #x118 +; :flag-assert #x1500b00118 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; swamp-rat +; (deftype swamp-rat (nav-enemy) +; ((~Tup-vector vector :inline :offset-assert 400) +; (~Tstate-float float :offset-assert 416) +; (~Tstate-vector vector :inline :offset-assert 432) +; (~Tfree-time uint64 :offset-assert 360) +; (~Twiggle-time uint64 :offset-assert 456) +; (~Twiggle-angle float :offset-assert 464) +; (~Tdelta-wiggle-angle float :offset-assert 468) +; (~Twiggle-factor float :offset-assert 472) +; (~Tmin-height float :offset-assert 476) +; (~Tchase-rest-time uint64 :offset-assert 480) +; (~Ttarget-nav-time uint64 :offset-assert 488) +; ) +; :method-count-assert 76 +; :size-assert #x1f0 +; :flag-assert #x4c018001f0 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; swamp-rat-nest +; (deftype swamp-rat-nest (process-drawable) +; ((~Tdummy uint32 :offset-assert 176) +; (~Tdamaged basic :offset-assert 180) +; (~Tdummy-type int8 :offset-assert 184) +; (~Trat-count int8 :offset-assert 185) +; (~Thit-points int8 :offset-assert 186) +; (~Tdefensive-rat-count int8 :offset-assert 187) +; (~Tspawn-period float :offset-assert 188) +; (~Tspawn-period-scale float :offset-assert 192) +; (~Ttest-interval uint64 :offset-assert 200) +; (~Tplayer-attack-id int32 :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xd4 +; :flag-assert #x14007000d4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; swamp-rat-nest +; (deftype swamp-rat-nest-dummy (process-drawable) +; ((~Ttop-sphere sphere :inline :offset-assert 176) +; (~Tdeath-part basic :offset-assert 192) +; (~Tspawn-joint-array UNKNOWN 6 :offset-assert 196) +; (~Tspawn-joint-count int8 :offset-assert 202) +; (~Tparticle-spawn-joint int8 :offset-assert 203) +; ) +; :method-count-assert 22 +; :size-assert #xcc +; :flag-assert #x16006000cc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; swamp-rat-nest +; (deftype swamp-rat-nest-dummy-a (swamp-rat-nest-dummy) +; () +; :method-count-assert 22 +; :size-assert #xcc +; :flag-assert #x16006000cc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; swamp-rat-nest +; (deftype swamp-rat-nest-dummy-b (swamp-rat-nest-dummy) +; () +; :method-count-assert 22 +; :size-assert #xcc +; :flag-assert #x16006000cc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; swamp-rat-nest +; (deftype swamp-rat-nest-dummy-c (swamp-rat-nest-dummy) +; () +; :method-count-assert 22 +; :size-assert #xcc +; :flag-assert #x16006000cc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; kermit +; (deftype joint-mod-tracker (basic) +; ((target-pos vector :inline :offset-assert 16) +; (target-pos-func basic :offset-assert 32) +; (inv-forward-scale-factor float :offset-assert 36) +; (forward-scale-control float :offset-assert 40) +; (forward-scale-max float :offset-assert 44) +; (process basic :offset-assert 48) +; (enable basic :offset-assert 52) +; (up-axis int8 :offset-assert 56) +; (forward-axis int8 :offset-assert 57) +; ) +; :method-count-assert 9 +; :size-assert #x3a +; :flag-assert #x90000003a +; ) + +; ;; kermit +; (deftype kermit-pulse (process-drawable) +; ((~Tsound-id uint32 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; kermit +; (deftype kermit (nav-enemy) +; ((~Trotate-dir vector :inline :offset-assert 400) +; (~Tcharging-part basic :offset-assert 416) +; (~Tairborne basic :offset-assert 420) +; (~Ttongue-control basic :offset-assert 424) +; (~Ttongue-pulse-pos float :offset-assert 428) +; (~Tmiss-count int8 :offset-assert 432) +; (~Tcharged-up basic :offset-assert 436) +; (~Tsound-id uint32 :offset-assert 440) +; ) +; :method-count-assert 76 +; :size-assert #x1bc +; :flag-assert #x4c015001bc +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; swamp-part +; (deftype swamp-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; billy +; (deftype billy (process-taskable) +; ((~Tfarthy uint64 :offset-assert 384) +; (~Tpath-data UNKNOWN 3 :offset-assert 392) +; (~Tpath-snacks basic :offset-assert 392) +; (~Tpath-starts basic :offset-assert 396) +; (~Tpath-waypts basic :offset-assert 400) +; (~Tpassed-last-stage basic :offset-assert 404) +; (~Tspawn-rats basic :offset-assert 408) +; (~Tcurrent-wave int32 :offset-assert 412) +; (~Twave-start-time uint64 :offset-assert 416) +; (~Tnum-snacks int32 :offset-assert 424) +; (~Tnum-rats int32 :offset-assert 428) +; (~Tmax-rats int32 :offset-assert 432) +; (~Trat-speed float :offset-assert 436) +; (~Toffending-rat uint64 :offset-assert 440) +; ) +; :method-count-assert 53 +; :size-assert #x1c0 +; :flag-assert #x35015001c0 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; billy +; (deftype billy-snack (process-drawable) +; ((~Tnum-rats int32 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; billy +; (deftype billy-rat (swamp-rat) +; ((~Tdest-type uint64 :offset-assert 496) +; (~Tsnack uint64 :offset-assert 504) +; (~Tdestination vector :inline :offset-assert 512) +; (~Tbilly uint32 :offset-assert 528) +; ) +; :method-count-assert 76 +; :size-assert #x214 +; :flag-assert #x4c01b00214 +; ;; inherited inpspect of swamp-rat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; cavecrystal-light +; (deftype cavecrystal-light (structure) +; ((next cavecrystal-light :offset-assert 0) +; (crystal-id int32 :offset-assert 4) +; (intensity float :offset-assert 8) +; (fade-start float :offset-assert 12) +; (fade-end float :offset-assert 16) +; (crystal-handle uint64 :offset-assert 24) +; (trans vector :inline :offset-assert 32) +; ) +; :method-count-assert 9 +; :size-assert #x30 +; :flag-assert #x900000030 +; ) + +; ;; cavecrystal-light +; (deftype cavecrystal-light-control (basic) +; ((active-count int32 :offset-assert 4) +; (head cavecrystal-light :offset-assert 8) +; (last-known-valid-time uint64 :offset-assert 16) +; (crystal UNKNOWN 7 :offset-assert 32) +; ) +; :method-count-assert 15 +; :size-assert #x170 +; :flag-assert #xf00000170 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; maincave-obs +; (deftype maincavecam (pov-camera) +; ((~Tseq uint64 :offset-assert 224) +; ) +; :method-count-assert 30 +; :size-assert #xe8 +; :flag-assert #x1e008000e8 +; ;; inherited inpspect of pov-camera +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; maincave-obs +; (deftype cave-water (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; maincave-obs +; (deftype cavecrusher (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; maincave-obs +; (deftype cavetrapdoor (process-drawable) +; ((~Tdelay-before-wiggle int32 :offset-assert 176) +; ) +; :method-count-assert 22 +; :size-assert #xb4 +; :flag-assert #x16005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; maincave-obs +; (deftype caveflamepots (process-drawable) +; ((~Tshove-up float :offset-assert 176) +; (~Tcycle-speed int32 :offset-assert 180) +; (~Tcycle-pause int32 :offset-assert 184) +; (~Tcycle-offset uint32 :offset-assert 188) +; (~Twas-deadly? basic :offset-assert 192) +; (~Tshould-play-sound? basic :offset-assert 196) +; (~Tlaunch-pos UNKNOWN 2 :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xf0 +; :flag-assert #x14008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; maincave-obs +; (deftype cavespatula (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; maincave-obs +; (deftype cavespatulatwo (process-drawable) +; ((~Tsync sync-info :inline :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; maincave-obs +; (deftype caveelevator (process-drawable) +; ((~Telev-mode uint64 :offset-assert 176) +; (~Telev-type int32 :offset-assert 184) +; (~Tprev-frame-num float :offset-assert 188) +; (~Tlast-update-bounce-time uint64 :offset-assert 192) +; (~Torig-trans vector :inline :offset-assert 208) +; (~Tsync sync-info :inline :offset-assert 224) +; (~Tsmush smush-control :inline :offset-assert 232) +; (~Tanim UNKNOWN 2 :offset-assert 264) +; (~Twheel-ry-mat matrix :inline :offset-assert 272) +; ) +; :method-count-assert 22 +; :size-assert #x150 +; :flag-assert #x1600e00150 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; maincave-part +; (deftype maincave-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; maincave-part +; (deftype darkcave-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; spiderwebs +; (deftype spiderwebs (process-drawable) +; ((~Tspring-height meters :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; dark-crystal +; (deftype dark-crystal (process-drawable) +; ((~Tcrystal-num int32 :offset-assert 176) +; (~Tunderwater? basic :offset-assert 180) +; (~Texplode-danger-radius float :offset-assert 184) +; (~Tlit-color-mult vector :inline :offset-assert 192) +; (~Tlit-color-emissive vector :inline :offset-assert 208) +; (~Tunlit-color-mult vector :inline :offset-assert 224) +; (~Tunlit-color-emissive vector :inline :offset-assert 240) +; ) +; :method-count-assert 22 +; :size-assert #x100 +; :flag-assert #x1600900100 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; baby-spider +; (deftype baby-spider-spawn-params (structure) +; ((hatched? basic :offset-assert 0) +; (fast-start? basic :offset-assert 4) +; (hack-move-above-ground? basic :offset-assert 8) +; (die-if-not-visible? basic :offset-assert 12) +; (pickup int32 :offset-assert 16) +; (pickup-amount int32 :offset-assert 20) +; (event-death basic :offset-assert 24) +; (delay-before-dying-if-not-visible uint64 :offset-assert 32) +; ) +; :method-count-assert 11 +; :size-assert #x28 +; :flag-assert #xb00000028 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; ) +; ) + +; ;; baby-spider +; (deftype baby-spider (nav-enemy) +; ((~Tdie-if-not-visible? basic :offset-assert 400) +; (~Thack-move-above-ground? basic :offset-assert 404) +; (~Tstate-float float :offset-assert 408) +; (~Twiggle-angle float :offset-assert 412) +; (~Tdelta-wiggle-angle float :offset-assert 416) +; (~Twiggle-factor float :offset-assert 420) +; (~Tevent-death basic :offset-assert 424) +; (~Tdelay-before-dying-if-not-visible uint64 :offset-assert 432) +; (~Tchase-rest-time uint64 :offset-assert 440) +; (~Ttarget-nav-time uint64 :offset-assert 448) +; (~Tfree-time uint64 :offset-assert 360) +; (~Twiggle-time uint64 :offset-assert 464) +; (~Tlast-visible-time uint64 :offset-assert 472) +; (~Tup-vector vector :inline :offset-assert 480) +; (~Tstate-vector vector :inline :offset-assert 496) +; ) +; :method-count-assert 76 +; :size-assert #x200 +; :flag-assert #x4c01900200 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; mother-spider-h +; (deftype mother-spider-leg (process-drawable) +; ((~Tgravity float :offset-assert 176) +; (~Ttransv vector :inline :offset-assert 192) +; (~Tfacing-rot vector :inline :offset-assert 208) +; (~Tfacing-rotv vector :inline :offset-assert 224) +; ) +; :method-count-assert 20 +; :size-assert #xf0 +; :flag-assert #x14008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; mother-spider-h +; (deftype mother-spider-thread (structure) +; ((joint-index int32 :offset-assert 0) +; (trans-u float :offset-assert 4) +; (swing-arc-u float :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; mother-spider-h +; (deftype mother-spider-leg-info (structure) +; ((joint-index0 int32 :offset-assert 0) +; (joint-index1 int32 :offset-assert 4) +; (cprim-index int32 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; mother-spider-h +; (deftype mother-spider-history (structure) +; ((trans vector :inline :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; mother-spider-h +; (deftype mother-spider-history-array (inline-array-class) +; ((length int32 :offset-assert 4) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; mother-spider-h +; (deftype mother-spider (process-drawable) +; ((~Tmode uint64 :offset-assert 176) +; (~Tdamage int32 :offset-assert 184) +; (~Tbaby-count int32 :offset-assert 188) +; (~Tmax-baby-count int32 :offset-assert 192) +; (~Tbirthing-counter int32 :offset-assert 196) +; (~Tspit-counter int32 :offset-assert 200) +; (~Tleg-socket-part-mask int32 :offset-assert 204) +; (~Tdist-from-anchor float :offset-assert 208) +; (~Ttarg-dist-from-anchor float :offset-assert 212) +; (~Tidle-dist-from-anchor float :offset-assert 216) +; (~Tplayer-sticky-dist-from-anchor float :offset-assert 220) +; (~Tmax-dist-from-anchor float :offset-assert 224) +; (~Tactivate-xz-dist float :offset-assert 228) +; (~Tdeactivate-xz-dist float :offset-assert 232) +; (~Tmax-spit-xz-dist float :offset-assert 236) +; (~Tmax-swing-radius float :offset-assert 240) +; (~Tspin-vel float :offset-assert 244) +; (~Tthread-speed float :offset-assert 248) +; (~Tthread-vel float :offset-assert 252) +; (~Thistory basic :offset-assert 256) +; (~Thistory-len int32 :offset-assert 260) +; (~Thistory-next-index int32 :offset-assert 264) +; (~Thit? basic :offset-assert 268) +; (~Tgoing-up? basic :offset-assert 272) +; (~Tcheck-z-thresh? basic :offset-assert 276) +; (~Tactivate-z-thresh float :offset-assert 280) +; (~Tdeactivate-z-thresh float :offset-assert 284) +; (~Tspawned-time uint64 :offset-assert 288) +; (~Tlast-update-time uint64 :offset-assert 296) +; (~Tspin-time uint64 :offset-assert 304) +; (~Tlast-spit-time uint64 :offset-assert 312) +; (~Tlast-player-in-air-time uint64 :offset-assert 320) +; (~Tstarted-birthing-time uint64 :offset-assert 328) +; (~Tneck basic :offset-assert 336) +; (~Tplayer-attack-id uint64 :offset-assert 344) +; (~Tleg-socket-part-time UNKNOWN 6 :offset-assert 352) +; (~Torient-rot vector :inline :offset-assert 400) +; (~Tanchor-trans vector :inline :offset-assert 416) +; (~Tthread-min-trans vector :inline :offset-assert 432) +; (~Tswing-pos vector :inline :offset-assert 448) +; (~Tswing-base-pos vector :inline :offset-assert 464) +; (~Tswing-vel vector :inline :offset-assert 480) +; ) +; :method-count-assert 32 +; :size-assert #x1f0 +; :flag-assert #x20018001f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; ) +; ) + +; ;; mother-spider-egg +; (deftype mother-spider-egg (process-drawable) +; ((~Tanim-speed float :offset-assert 176) +; (~Tpart2 basic :offset-assert 180) +; (~Tfalling-start-time uint64 :offset-assert 184) +; (~Tfall-dest vector :inline :offset-assert 192) +; (~Tfall-dest-normal vector :inline :offset-assert 208) +; (~Tbroken-look lod-set :inline :offset-assert 224) +; (~Ttraj trajectory :inline :offset-assert 272) +; (~Tshadow-pos vector :inline :offset-assert 320) +; ) +; :method-count-assert 22 +; :size-assert #x150 +; :flag-assert #x1600e00150 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; mother-spider-proj +; (deftype mother-spider-proj (projectile) +; ((~Tfacing-dir vector :inline :offset-assert 416) +; ) +; :method-count-assert 29 +; :size-assert #x1b0 +; :flag-assert #x1d014001b0 +; ;; inherited inpspect of projectile +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; gnawer +; (deftype gnawer-falling-segment (process-drawable) +; ((~Ttransv vector :inline :offset-assert 176) +; (~Tfacing-rot vector :inline :offset-assert 192) +; (~Tfacing-rotv vector :inline :offset-assert 208) +; ) +; :method-count-assert 21 +; :size-assert #xe0 +; :flag-assert #x15007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; gnawer +; (deftype gnawer-segment-info (structure) +; ((num-joints int32 :offset-assert 0) +; (joint-index UNKNOWN 8 :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #xc +; :flag-assert #x90000000c +; ) + +; ;; gnawer +; (deftype gnawer-segment (structure) +; ((place int32 :offset-assert 0) +; (world-pos vector :inline :offset-assert 16) +; (anim-to-local-trans-offset vector :inline :offset-assert 32) +; (orient-mat matrix :inline :offset-assert 48) +; ) +; :method-count-assert 9 +; :size-assert #x70 +; :flag-assert #x900000070 +; ) + +; ;; gnawer +; (deftype gnawer-route (structure) +; ((src-pt-index int32 :offset-assert 0) +; (dest-pt-index int32 :offset-assert 4) +; (total-travel-time uint64 :offset-assert 8) +; (src-ang float :offset-assert 16) +; (dest-ang float :offset-assert 20) +; (delta-ang float :offset-assert 24) +; (surface-dist float :offset-assert 28) +; (total-dist float :offset-assert 32) +; (src-pt-offset vector :inline :offset-assert 48) +; (dest-pt-offset vector :inline :offset-assert 64) +; (surface-dir vector :inline :offset-assert 80) +; ) +; :method-count-assert 9 +; :size-assert #x60 +; :flag-assert #x900000060 +; ) + +; ;; gnawer +; (deftype gnawer (process-drawable) +; ((~Thit-points int32 :offset-assert 176) +; (~Tgnawer-id int32 :offset-assert 180) +; (~Ttotal-money int32 :offset-assert 184) +; (~Tmoney-mask uint32 :offset-assert 188) +; (~Teco-green-mask uint32 :offset-assert 192) +; (~Thidden? basic :offset-assert 196) +; (~Tshow-damage? basic :offset-assert 200) +; (~Troute-dist float :offset-assert 204) +; (~Tspeed float :offset-assert 208) +; (~Tanim-speed float :offset-assert 212) +; (~Tpart2 basic :offset-assert 216) +; (~Tsound2 basic :offset-assert 220) +; (~Tlast-hit-time uint64 :offset-assert 224) +; (~Tpost-trans vector :inline :offset-assert 240) +; (~Tfall-trans vector :inline :offset-assert 256) +; (~Troute gnawer-route :inline :offset-assert 272) +; (~Tsegments UNKNOWN 10 :offset-assert 368) +; ) +; :method-count-assert 31 +; :size-assert #x5d0 +; :flag-assert #x1f056005d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; ) +; ) + +; ;; driller-lurker +; (deftype driller-lurker (process-drawable) +; ((~Thit-player? basic :offset-assert 176) +; (~Tplayed-drill-sound? basic :offset-assert 180) +; (~Tmode uint64 :offset-assert 184) +; (~Tpath-u float :offset-assert 192) +; (~Tpath-units-per-meter float :offset-assert 196) +; (~Tpath-speed float :offset-assert 200) +; (~Ttarg-path-speed float :offset-assert 204) +; (~Tpath-dir float :offset-assert 208) +; (~Tpath-ry float :offset-assert 212) +; (~Tfacing-ry float :offset-assert 216) +; (~Tdrill-rz float :offset-assert 220) +; (~Tdrill-speed float :offset-assert 224) +; (~Tup-blend float :offset-assert 228) +; (~Tplayer-path-u float :offset-assert 232) +; (~Tambient-drilling-u float :offset-assert 236) +; (~Ttimeout int32 :offset-assert 240) +; (~Tneck basic :offset-assert 244) +; (~Tdrill basic :offset-assert 248) +; (~Tsound2 basic :offset-assert 252) +; (~Tlast-update-time uint64 :offset-assert 256) +; (~Tlast-player-path-u-time uint64 :offset-assert 264) +; (~Tstarted-chasing-time uint64 :offset-assert 272) +; (~Thit-player-time uint64 :offset-assert 280) +; (~Tplayer-attack-id uint64 :offset-assert 288) +; ) +; :method-count-assert 28 +; :size-assert #x128 +; :flag-assert #x1c00c00128 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + +; ;; sunken-part +; (deftype sunken-part (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; target-tube +; (deftype tube-info (basic) +; ((entity basic :offset-assert 4) +; (tube uint64 :offset-assert 8) +; (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) +; (turn-anim-targ float :offset-assert 128) +; (turn-anim-frame float :offset-assert 132) +; (turn-anim-vel float :offset-assert 136) +; (tube-sound-id uint32 :offset-assert 140) +; (tube-sound-vol float :offset-assert 144) +; ) +; :method-count-assert 9 +; :size-assert #x94 +; :flag-assert #x900000094 +; ) + +; ;; target-tube +; (deftype tube-bank (basic) +; () +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ) + +; ;; target-tube +; (deftype slide-control (process-drawable) +; ((~Ttarget uint64 :offset-assert 176) +; (~Tpos float :offset-assert 184) +; (~Ttrans vector :inline :offset-assert 192) +; (~Trot vector :inline :offset-assert 208) +; (~Tside vector :inline :offset-assert 224) +; ) +; :method-count-assert 22 +; :size-assert #xf0 +; :flag-assert #x16008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; sunken-obs +; (deftype water-vol-deadly (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; sunken-obs +; (deftype side-to-side-plat (plat) +; ((~Tpart-ry float :offset-assert 264) +; ) +; :method-count-assert 33 +; :size-assert #x10c +; :flag-assert #x2100a0010c +; ;; inherited inpspect of plat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; sunken-obs +; (deftype sunkencam (pov-camera) +; ((~Tseq uint64 :offset-assert 224) +; ) +; :method-count-assert 30 +; :size-assert #xe8 +; :flag-assert #x1e008000e8 +; ;; inherited inpspect of pov-camera +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; sunken-obs +; (deftype seaweed (process-drawable) +; ((~Tanim-speed float :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; shover +; (deftype shover (process-drawable) +; ((~Tshove-up float :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; square-platform +; (deftype square-platform (baseplat) +; ((~Tplat-id int32 :offset-assert 228) +; (~Tpos-u float :offset-assert 232) +; (~Twater-entity basic :offset-assert 236) +; (~Tsplash-counter int32 :offset-assert 240) +; (~Tstart-splash-time uint64 :offset-assert 248) +; (~Tpart2 basic :offset-assert 256) +; (~Tpart3 basic :offset-assert 260) +; (~Tpart4 basic :offset-assert 264) +; (~Tup-pos vector :inline :offset-assert 272) +; (~Tdown-pos vector :inline :offset-assert 288) +; ) +; :method-count-assert 28 +; :size-assert #x130 +; :flag-assert #x1c00c00130 +; ;; inherited inpspect of baseplat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + +; ;; square-platform +; (deftype square-platform-button (basebutton) +; () +; :method-count-assert 32 +; :size-assert #x100 +; :flag-assert #x2000900100 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; ) +; ) + +; ;; square-platform +; (deftype square-platform-master (process-drawable) +; ((~Tbutton-id int32 :offset-assert 176) +; (~Tplat-id int32 :offset-assert 180) +; (~Tplat-mask uint32 :offset-assert 184) +; (~Tplat-id-dir int32 :offset-assert 188) +; (~Twiggled? basic :offset-assert 192) +; (~Ttimeout uint64 :offset-assert 200) +; (~Tlast-plat-activated-time uint64 :offset-assert 208) +; (~Tdelay-til-wiggle uint64 :offset-assert 216) +; (~Tticker ticky :inline :offset-assert 224) +; ) +; :method-count-assert 20 +; :size-assert #x100 +; :flag-assert #x1400900100 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; sun-iris-door +; (deftype sun-iris-door (process-drawable) +; ((~Ttimeout float :offset-assert 176) +; (~Tproximity? basic :offset-assert 180) +; (~Tdirectional-proximity? basic :offset-assert 184) +; (~Tmove-to? basic :offset-assert 188) +; (~Tlocked-by-task? basic :offset-assert 192) +; (~Tclose-dist float :offset-assert 196) +; (~Topen-dist float :offset-assert 200) +; (~Tmove-to-pos vector :inline :offset-assert 208) +; (~Toutward-vec vector :inline :offset-assert 224) +; (~Tmove-to-quat quaternion :inline :offset-assert 240) +; ) +; :method-count-assert 22 +; :size-assert #x100 +; :flag-assert #x1600900100 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; orbit-plat +; (deftype orbit-plat-bottom (process-drawable) +; ((~Tpart2 basic :offset-assert 176) +; ) +; :method-count-assert 21 +; :size-assert #xb4 +; :flag-assert #x15005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; orbit-plat +; (deftype orbit-plat (baseplat) +; ((~Tother basic :offset-assert 228) +; (~Trot-dir float :offset-assert 232) +; (~Treset-trans vector :inline :offset-assert 240) +; (~Tis-reset? basic :offset-assert 256) +; (~Treset-length float :offset-assert 260) +; (~Ttimeout float :offset-assert 264) +; (~Tplat-status uint64 :offset-assert 272) +; ) +; :method-count-assert 29 +; :size-assert #x118 +; :flag-assert #x1d00b00118 +; ;; inherited inpspect of baseplat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; wedge-plats +; (deftype wedge-plat-master (process) +; ((~Tcenter vector :inline :offset-assert 112) +; (~Trotspeed float :offset-assert 128) +; (~Trotate-inner float :offset-assert 132) +; (~Trotate-outer float :offset-assert 136) +; ) +; :method-count-assert 14 +; :size-assert #x8c +; :flag-assert #xe0020008c +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; ) +; ) + +; ;; wedge-plats +; (deftype wedge-plat (baseplat) +; ((~Tmaster basic :offset-assert 228) +; (~Tdistance float :offset-assert 232) +; (~Toffset float :offset-assert 236) +; ) +; :method-count-assert 28 +; :size-assert #xf0 +; :flag-assert #x1c008000f0 +; ;; inherited inpspect of baseplat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + +; ;; wedge-plats +; (deftype wedge-plat-outer (wedge-plat) +; () +; :method-count-assert 28 +; :size-assert #xf0 +; :flag-assert #x1c008000f0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + +; ;; wall-plat +; (deftype wall-plat (process-drawable) +; ((~Tuse-sync? basic :offset-assert 176) +; (~Textended-amount float :offset-assert 180) +; (~Tin-trans vector :inline :offset-assert 192) +; (~Tout-trans vector :inline :offset-assert 208) +; (~Tsync sync-info-paused :inline :offset-assert 224) +; ) +; :method-count-assert 20 +; :size-assert #xf0 +; :flag-assert #x14008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; qbert-plat +; (deftype qbert-plat-on (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; qbert-plat +; (deftype qbert-plat (rigid-body-platform) +; ((~Tanchor-point vector :inline :offset-assert 736) +; (~Tplat-id int32 :offset-assert 752) +; (~Ton? basic :offset-assert 756) +; (~Tplayer-is-riding? basic :offset-assert 760) +; (~Tmaster basic :offset-assert 764) +; ) +; :method-count-assert 35 +; :size-assert #x300 +; :flag-assert #x2302900300 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; qbert-plat +; (deftype qbert-plat-master (process-drawable) +; ((~Tlast-plat-triggered int32 :offset-assert 176) +; (~Tplat-states uint32 :offset-assert 180) +; (~Tplat-states-needed-to-open-door uint32 :offset-assert 184) +; (~Tplayer-in-bounds? basic :offset-assert 188) +; (~Tplayer-in-water? basic :offset-assert 192) +; (~Tplay-door-cam? basic :offset-assert 196) +; (~Tpuzzle-beaten? basic :offset-assert 200) +; (~Tdoor basic :offset-assert 204) +; (~Tdoor-plat basic :offset-assert 208) +; (~Tbounds-start vector :inline :offset-assert 224) +; (~Tbounds-end vector :inline :offset-assert 240) +; ) +; :method-count-assert 21 +; :size-assert #x100 +; :flag-assert #x1500900100 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; steam-cap +; (deftype steam-cap-control-pt (structure) +; ((trans vector :inline :offset-assert 0) +; (transv vector :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; steam-cap +; (deftype steam-cap (process-drawable) +; ((~Tdo-burst? basic :offset-assert 176) +; (~Tdo-falling-sound? basic :offset-assert 180) +; (~Tdo-landing-sound? basic :offset-assert 184) +; (~Tbegin-travel-up float :offset-assert 188) +; (~Tbegin-travel-down float :offset-assert 192) +; (~Tsync sync-info :inline :offset-assert 196) +; (~Tpart2 basic :offset-assert 204) +; (~Tpart3 basic :offset-assert 208) +; (~Tdown vector :inline :offset-assert 224) +; (~Tup vector :inline :offset-assert 240) +; (~Tcontrol-pt UNKNOWN 3 :offset-assert 256) +; ) +; :method-count-assert 22 +; :size-assert #x160 +; :flag-assert #x1600f00160 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; sun-exit-chamber +; (deftype blue-eco-charger-orb (process-drawable) +; ((~Torbit-rot vector :inline :offset-assert 176) +; (~Torbit-rotv vector :inline :offset-assert 192) +; (~Ttarg-orbit-rotv vector :inline :offset-assert 208) +; (~Trest-pos vector :inline :offset-assert 224) +; ) +; :method-count-assert 21 +; :size-assert #xf0 +; :flag-assert #x15008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; sun-exit-chamber +; (deftype blue-eco-charger (process-drawable) +; ((~Tcharger-id int32 :offset-assert 176) +; (~Topen-level float :offset-assert 180) +; (~Tmaster basic :offset-assert 184) +; ) +; :method-count-assert 22 +; :size-assert #xbc +; :flag-assert #x16005000bc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; sun-exit-chamber +; (deftype exit-chamber-items (structure) +; ((door-pos vector :inline :offset-assert 0) +; (door-quat quaternion :inline :offset-assert 16) +; (button-pos vector :inline :offset-assert 32) +; (button-quat quaternion :inline :offset-assert 48) +; (fcell-pos vector :inline :offset-assert 64) +; ) +; :method-count-assert 9 +; :size-assert #x50 +; :flag-assert #x900000050 +; ) + +; ;; sun-exit-chamber +; (deftype exit-chamber (process-drawable) +; ((~Tchargers-active uint32 :offset-assert 176) +; (~Tmove-player? basic :offset-assert 180) +; (~Tmove-fcell? basic :offset-assert 184) +; (~Tplay-assistant-message? basic :offset-assert 188) +; (~Twave-scale float :offset-assert 192) +; (~Tbutton uint32 :offset-assert 196) +; (~Tdoor uint32 :offset-assert 200) +; (~Tfcell-handle uint64 :offset-assert 208) +; (~Torig-trans vector :inline :offset-assert 224) +; (~Tlast-pos vector :inline :offset-assert 240) +; ) +; :method-count-assert 25 +; :size-assert #x100 +; :flag-assert #x1900900100 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; ) +; ) + +; ;; sun-exit-chamber +; (deftype exit-chamber-button (basebutton) +; () +; :method-count-assert 32 +; :size-assert #x100 +; :flag-assert #x2000900100 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; ) +; ) + +; ;; floating-launcher +; (deftype floating-launcher (baseplat) +; ((~Ttrigger-height float :offset-assert 228) +; (~Tlauncher uint32 :offset-assert 232) +; ) +; :method-count-assert 27 +; :size-assert #xec +; :flag-assert #x1b008000ec +; ;; inherited inpspect of baseplat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; sunken-water +; (deftype sunken-water (water-anim) +; ((~Tuse-sync? basic :offset-assert 220) +; (~Tplaying-deadly-sound? basic :offset-assert 224) +; (~Tdeadly-time float :offset-assert 228) +; (~Tdeadly-fade float :offset-assert 232) +; (~Tsync sync-info :inline :offset-assert 236) +; (~Tsafe-color-mult vector :inline :offset-assert 256) +; (~Tsafe-color-emissive vector :inline :offset-assert 272) +; (~Tdeadly-color-mult vector :inline :offset-assert 288) +; (~Tdeadly-color-emissive vector :inline :offset-assert 304) +; ) +; :method-count-assert 31 +; :size-assert #x140 +; :flag-assert #x1f00d00140 +; ;; inherited inpspect of water-anim +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; ) +; ) + +; ;; whirlpool +; (deftype whirlpool (process-drawable) +; ((~Tspin-ry float :offset-assert 176) +; (~Tspin-speed-idle float :offset-assert 180) +; (~Tspin-speed-delta float :offset-assert 184) +; (~Tsync sync-info-paused :inline :offset-assert 188) +; ) +; :method-count-assert 21 +; :size-assert #xcc +; :flag-assert #x15006000cc +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; sunken-pipegame +; (deftype sunken-pipegame-button (basebutton) +; () +; :method-count-assert 32 +; :size-assert #x100 +; :flag-assert #x2000900100 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; ) +; ) + +; ;; sunken-pipegame +; (deftype sunken-pipegame-prize (structure) +; ((puzzle-delay uint64 :offset-assert 0) +; (pipe-travel-time-to-far uint64 :offset-assert 8) +; (pipe-travel-time-to-jar uint64 :offset-assert 16) +; (actor-handle uint64 :offset-assert 24) +; (jar-pos vector :inline :offset-assert 32) +; (far-pos vector :inline :offset-assert 48) +; (sucked-up-jar-part-pos vector :inline :offset-assert 64) +; (sucked-up-far-part-pos vector :inline :offset-assert 80) +; (blown-out-jar-part-pos vector :inline :offset-assert 96) +; (blown-out-far-part-pos vector :inline :offset-assert 112) +; (sucked-up-part basic :offset-assert 128) +; (blown-out-part basic :offset-assert 132) +; ) +; :method-count-assert 9 +; :size-assert #x88 +; :flag-assert #x900000088 +; ) + +; ;; sunken-pipegame +; (deftype sunken-pipegame (process-drawable) +; ((~Tabort-audio-if-beaten? basic :offset-assert 176) +; (~Tchallenges-mask uint32 :offset-assert 180) +; (~Tchallenge int32 :offset-assert 184) +; (~Tticker ticky :inline :offset-assert 192) +; (~Tbutton UNKNOWN 3 :offset-assert 224) +; (~Tprize UNKNOWN 3 :offset-assert 240) +; ) +; :method-count-assert 23 +; :size-assert #x2a0 +; :flag-assert #x17023002a0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; bully +; (deftype bully-broken-cage (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; bully +; (deftype bully (process-drawable) +; ((~Thit-player? basic :offset-assert 176) +; (~Tbounced? basic :offset-assert 180) +; (~Tbounce-volume int32 :offset-assert 184) +; (~Tfacing-ry float :offset-assert 188) +; (~Ttravel-ry float :offset-assert 192) +; (~Tspeed-u float :offset-assert 196) +; (~Tspin-vel float :offset-assert 200) +; (~Ttravel-speed float :offset-assert 204) +; (~Treaction-delay uint64 :offset-assert 208) +; (~Tstart-spin-time uint64 :offset-assert 216) +; (~Tslow-down uint64 :offset-assert 224) +; (~Thit-player-time uint64 :offset-assert 232) +; (~Tneck basic :offset-assert 240) +; ) +; :method-count-assert 21 +; :size-assert #xf4 +; :flag-assert #x15009000f4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; double-lurker +; (deftype double-lurker-top (nav-enemy) +; ((~Tfall-dest vector :inline :offset-assert 400) +; ) +; :method-count-assert 76 +; :size-assert #x1a0 +; :flag-assert #x4c013001a0 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; double-lurker +; (deftype double-lurker (nav-enemy) +; ((~Tknocked-back-speed float :offset-assert 400) +; (~Tbuddy-on-shoulders? basic :offset-assert 404) +; (~Tdead? basic :offset-assert 408) +; (~Tbuddy-dead? basic :offset-assert 412) +; (~Tbuddy-handle uint64 :offset-assert 416) +; ) +; :method-count-assert 76 +; :size-assert #x1a8 +; :flag-assert #x4c014001a8 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; helix-water +; (deftype helix-slide-door (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; helix-water +; (deftype helix-button (process-drawable) +; ((~Tmy-water basic :offset-assert 176) +; (~Tmy-door basic :offset-assert 180) +; (~Tfcell-handle uint64 :offset-assert 184) +; (~Tdown-y float :offset-assert 192) +; (~Tspawn-trans vector :inline :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xe0 +; :flag-assert #x14007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; helix-water +; (deftype helix-dark-eco (dark-eco-pool) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; helix-water +; (deftype helix-water (process-drawable) +; ((~Tlast-alt-actor-consumed int32 :offset-assert 176) +; (~Talt-actors basic :offset-assert 180) +; (~Ttransv-y float :offset-assert 184) +; (~Tstart-y float :offset-assert 188) +; (~Tend-y float :offset-assert 192) +; (~Tdark-eco uint32 :offset-assert 196) +; ) +; :method-count-assert 22 +; :size-assert #xc8 +; :flag-assert #x16006000c8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; puffer +; (deftype puffer (process-drawable) +; ((~Tpath-index int32 :offset-assert 176) +; (~Tfacing-ry float :offset-assert 180) +; (~Ttravel-ry float :offset-assert 184) +; (~Ttravel-speed float :offset-assert 188) +; (~Tattack-bottom-y float :offset-assert 192) +; (~Tpatrol-bottom-y float :offset-assert 196) +; (~Ttop-y float :offset-assert 200) +; (~Ttarg-trans-y float :offset-assert 204) +; (~Tacc-y float :offset-assert 208) +; (~Ttravel-turn-speed float :offset-assert 212) +; (~Tnotice-dist float :offset-assert 216) +; (~Tgive-up-dist float :offset-assert 220) +; (~Tattacking? basic :offset-assert 224) +; (~Thit-player? basic :offset-assert 228) +; (~Tlook-mean? basic :offset-assert 232) +; (~Tcprims-type uint64 :offset-assert 240) +; (~Tneck basic :offset-assert 248) +; (~Thit-player-time uint64 :offset-assert 256) +; (~Treaction-delay uint64 :offset-assert 264) +; (~Tpicked-point-time uint64 :offset-assert 272) +; (~Tpick-new-point-delay uint64 :offset-assert 280) +; (~Tlast-on-screen-time uint64 :offset-assert 288) +; (~Tbuddy basic :offset-assert 296) +; (~Tnice-look lod-set :inline :offset-assert 300) +; (~Tmean-look lod-set :inline :offset-assert 336) +; (~Tdest-pos vector :inline :offset-assert 384) +; (~Tsync sync-info :inline :offset-assert 400) +; ) +; :method-count-assert 32 +; :size-assert #x198 +; :flag-assert #x2001300198 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; ) +; ) + +; ;; puffer +; (deftype pick-patrol-point-away-from-buddy-work (structure) +; ((best-path-index int32 :offset-assert 0) +; (best-rating float :offset-assert 4) +; (best-dest vector :inline :offset-assert 16) +; (pt-dir vector :inline :offset-assert 32) +; (buddy-dir vector :inline :offset-assert 48) +; (dest vector :inline :offset-assert 64) +; ) +; :method-count-assert 9 +; :size-assert #x50 +; :flag-assert #x900000050 +; ) + +; ;; sunken-fish +; (deftype sunkenfisha (process-drawable) +; ((~Tpath-u float :offset-assert 176) +; (~Tpath-speed float :offset-assert 180) +; (~Tpath-speed-seek-speed float :offset-assert 184) +; (~Ttarg-path-speed float :offset-assert 188) +; (~Tpath-normal-speed-lo float :offset-assert 192) +; (~Tpath-normal-speed-hi float :offset-assert 196) +; (~Tpath-dir float :offset-assert 200) +; (~Tchange-path-dir-time uint64 :offset-assert 208) +; (~Tlocal-path-offset vector :inline :offset-assert 224) +; (~Ttarg-local-path-offset vector :inline :offset-assert 240) +; (~Tlocal-path-offset-dir vector :inline :offset-assert 256) +; (~Tmax-local-path-offset vector :inline :offset-assert 272) +; (~Tfacing-rot vector :inline :offset-assert 288) +; (~Tpath-trans-offset vector :inline :offset-assert 304) +; ) +; :method-count-assert 28 +; :size-assert #x140 +; :flag-assert #x1c00d00140 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + +; ;; rolling-obs +; (deftype rolling-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; rolling-obs +; (deftype rollingcam (process-hidden) +; ((name basic :offset-assert 4) +; (mask uint32 :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) +; (state basic :offset-assert 56) +; (trans-hook basic :offset-assert 60) +; (post-hook basic :offset-assert 64) +; (event-hook basic :offset-assert 68) +; (allocated-length int32 :offset-assert 72) +; (next-state basic :offset-assert 76) +; (heap-base uint32 :offset-assert 80) +; (heap-top uint32 :offset-assert 84) +; (heap-cur uint32 :offset-assert 88) +; (stack-frame-top basic :offset-assert 92) +; (heap kheap :inline :offset-assert 80) +; (connection-list 'connectable :inline :offset-assert 96) +; (stack UNKNOWN :dynamic :offset-assert 112) +; ) +; :method-count-assert 15 +; :size-assert #x70 +; :flag-assert #xf00000070 +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; ) +; ) + +; ;; rolling-obs +; (deftype pusher-base (process-drawable) +; ((~Tmax-frame float :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype pusher (pusher-base) +; ((~Tsync sync-info-paused :inline :offset-assert 180) +; (~Tcyl cylinder :inline :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xf8 +; :flag-assert #x14009000f8 +; ;; inherited inpspect of pusher-base +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype gorge-pusher (pusher-base) +; ((~Tmin-frame float :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of pusher-base +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype dark-plant (process-drawable) +; ((~Tnum-alts int32 :offset-assert 176) +; (~Talts UNKNOWN 4 :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xc4 +; :flag-assert #x14006000c4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype happy-plant (process-drawable) +; ((~Talt-actor basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype race-time (structure) +; ((digit UNKNOWN 5 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x5 +; :flag-assert #x900000005 +; ) + +; ;; rolling-obs +; (deftype rolling-start (process-drawable) +; ((~Twhole-look lod-set :inline :offset-assert 176) +; (~Tbroken-look lod-set :inline :offset-assert 212) +; ) +; :method-count-assert 20 +; :size-assert #xf5 +; :flag-assert #x14009000f5 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype gorge (process-drawable) +; ((~Tcoord matrix :inline :offset-assert 176) +; (~Tradius float :offset-assert 240) +; (~Tthickness float :offset-assert 244) +; ) +; :method-count-assert 20 +; :size-assert #xf8 +; :flag-assert #x14009000f8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype gorge-start (gorge) +; ((~Ttasks basic :offset-assert 248) +; (~Trecord-time race-time :inline :offset-assert 252) +; (~Tthis-time race-time :inline :offset-assert 257) +; (~Tstart-banner uint64 :offset-assert 264) +; (~Tend-banner uint64 :offset-assert 272) +; (~Ttimer-pos-offset int32 :offset-assert 280) +; (~Tticker ticky :inline :offset-assert 288) +; ) +; :method-count-assert 20 +; :size-assert #x140 +; :flag-assert #x1400d00140 +; ;; inherited inpspect of gorge +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype gorge-finish (gorge) +; ((~Talt-actor basic :offset-assert 248) +; ) +; :method-count-assert 20 +; :size-assert #xfc +; :flag-assert #x14009000fc +; ;; inherited inpspect of gorge +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype gorge-abort (gorge) +; () +; :method-count-assert 20 +; :size-assert #xf8 +; :flag-assert #x14009000f8 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-obs +; (deftype rolling-water (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; rolling-lightning-mole +; (deftype fleeing-nav-enemy-info (structure) +; ((min-reflect-angle float :offset-assert 0) +; (max-reflect-angle float :offset-assert 4) +; (max-boundary-deflection float :offset-assert 8) +; (deflection-min-dist float :offset-assert 12) +; (deflection-max-dist float :offset-assert 16) +; (reflection-time int32 :offset-assert 20) +; (travel-rotate-speed float :offset-assert 24) +; (blend_interp_angle float :offset-assert 28) +; (min-speed-adjust float :offset-assert 32) +; (max-speed-adjust float :offset-assert 36) +; (speed-adjust-center float :offset-assert 40) +; (speed-adjust-range float :offset-assert 44) +; (abort-notice-distance float :offset-assert 48) +; (min-notice-dist float :offset-assert 52) +; (max-notice-dist float :offset-assert 56) +; (min-stop-chase-dist float :offset-assert 60) +; (max-stop-chase-dist float :offset-assert 64) +; (max-flee-rotation float :offset-assert 68) +; ) +; :method-count-assert 9 +; :size-assert #x48 +; :flag-assert #x900000048 +; ) + +; ;; rolling-lightning-mole +; (deftype fleeing-nav-enemy (nav-enemy) +; ((~Tlast-reflection-time uint64 :offset-assert 400) +; (~Trun-blend-interp float :offset-assert 408) +; (~Tdesired-travel vector :inline :offset-assert 416) +; (~Tsaved-travel vector :inline :offset-assert 432) +; (~Tspeed-adjust float :offset-assert 448) +; (~Tflee-info fleeing-nav-enemy-info :inline :offset-assert 452) +; ) +; :method-count-assert 76 +; :size-assert #x20c +; :flag-assert #x4c01a0020c +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; rolling-lightning-mole +; (deftype lightning-mole (fleeing-nav-enemy) +; ((~Tdebug-vector vector :inline :offset-assert 528) +; (~Talt-actor basic :offset-assert 544) +; ) +; :method-count-assert 76 +; :size-assert #x224 +; :flag-assert #x4c01c00224 +; ;; inherited inpspect of fleeing-nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; rolling-lightning-mole +; (deftype peeper (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-robber +; (deftype robber (process-drawable) +; ((~Tcurve-position float :offset-assert 176) +; (~Tspeed float :offset-assert 180) +; (~Tfacing vector :inline :offset-assert 192) +; (~Ttangent vector :inline :offset-assert 208) +; (~Trun-blend-interp float :offset-assert 224) +; (~Tnear-timer int32 :offset-assert 228) +; (~Tfar-time uint64 :offset-assert 232) +; (~Ty-offset float :offset-assert 240) +; (~Ty-offset-desired float :offset-assert 244) +; (~Ty-vel float :offset-assert 248) +; (~Twater-height float :offset-assert 252) +; (~Ttimeout uint64 :offset-assert 256) +; (~Tlast-ambient-time uint64 :offset-assert 264) +; (~Ttime-to-next-ambient uint64 :offset-assert 272) +; ) +; :method-count-assert 20 +; :size-assert #x118 +; :flag-assert #x1400b00118 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; rolling-race-ring +; (deftype race-ring (process-drawable) +; ((~Trot-y float :offset-assert 176) +; (~Tface-vec vector :inline :offset-assert 192) +; (~Tpart-track uint64 :offset-assert 208) +; (~Tkeep-part-track-alive basic :offset-assert 216) +; (~Ttimeout uint64 :offset-assert 224) +; (~Talt-actor basic :offset-assert 232) +; (~Talt-task uint8 :offset-assert 236) +; (~Tcyl cylinder-flat :inline :offset-assert 240) +; (~Told-hips vector :inline :offset-assert 288) +; ) +; :method-count-assert 20 +; :size-assert #x130 +; :flag-assert #x1400c00130 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; firecanyon-obs +; (deftype balloon (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; firecanyon-obs +; (deftype spike (process-drawable) +; ((~Tnum-alts int32 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; firecanyon-obs +; (deftype crate-darkeco-cluster (process-drawable) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; ogre-part +; (deftype ogre-part (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; ogreboss +; (deftype ogreboss-missile (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; ogreboss +; (deftype ogreboss-missile-init-data (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; bad get label +; ) + +; ;; ogreboss +; (deftype ogreboss-super-boulder (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; ogreboss +; (deftype ogreboss-bounce-boulder (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; ogreboss +; (deftype ogreboss (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; unrecognized get op: (set! v1 process-drawable) parent was UNKNOWN +; ) + +; ;; ogre-obs +; (deftype tntbarrel (process-drawable) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-plat (rigid-body-platform) +; ((~Tanchor-point vector :inline :offset-assert 736) +; (~Tidle-y-offset float :offset-assert 752) +; (~Tfloat-y-offset float :offset-assert 756) +; (~Tdelay uint64 :offset-assert 760) +; (~Tactive basic :offset-assert 768) +; (~Ttriggered basic :offset-assert 772) +; ) +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; inherited inpspect of rigid-body-platform +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-step (ogre-plat) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-step-a (ogre-step) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-step-b (ogre-step) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-step-c (ogre-step) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-step-d (ogre-step) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-isle (ogre-plat) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-isle-b (ogre-isle) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-isle-c (ogre-isle) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-isle-d (ogre-isle) +; () +; :method-count-assert 35 +; :size-assert #x308 +; :flag-assert #x2302a00308 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-bridge (process-drawable) +; ((~Tjoint-mod-array UNKNOWN 8 :offset-assert 176) +; (~Tdead-joint-count int8 :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xd1 +; :flag-assert #x14007000d1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-bridgeend (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; ogre-obs +; (deftype ogre-lava (water-anim) +; ((~Tidle-anim int32 :offset-assert 220) +; (~Tanim int32 :offset-assert 224) +; ) +; :method-count-assert 30 +; :size-assert #xe4 +; :flag-assert #x1e008000e4 +; ;; inherited inpspect of water-anim +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; ogre-obs +; (deftype shortcut-boulder (process-drawable) +; ((~Tbroken-look lod-set :inline :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xd1 +; :flag-assert #x14007000d1 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; flying-lurker +; (deftype plunger-lurker (process-drawable) +; ((~Talt-actor basic :offset-assert 176) +; (~Tgot-hit basic :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; flying-lurker +; (deftype flying-lurker (process-drawable) +; ((~Tcurve-position float :offset-assert 176) +; (~Tspeed float :offset-assert 180) +; (~Ttangent vector :inline :offset-assert 192) +; (~Tanim-blend float :offset-assert 208) +; (~Ty-offset float :offset-assert 212) +; (~Ty-offset-desired float :offset-assert 216) +; (~Ty-vel float :offset-assert 220) +; (~Tlast-look-time uint64 :offset-assert 224) +; (~Ttime-to-next-look uint64 :offset-assert 232) +; (~Ttake-off basic :offset-assert 240) +; (~Trace-seconds float :offset-assert 244) +; (~Trace-start-time uint64 :offset-assert 248) +; (~Trank int32 :offset-assert 256) +; (~Talt-actor basic :offset-assert 260) +; (~Talt-trans vector :offset-assert 264) +; (~Tshadow-backup basic :offset-assert 268) +; (~Ttry-count uint8 :offset-assert 272) +; (~Ttry-counted basic :offset-assert 276) +; (~Tdefault-bounds vector :inline :offset-assert 288) +; ) +; :method-count-assert 21 +; :size-assert #x130 +; :flag-assert #x1500c00130 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; village3-part +; (deftype villagec-part (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; village3-obs +; (deftype villagec-lava (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; village3-obs +; (deftype gondola (process-drawable) +; ((~Tanim basic :offset-assert 176) +; (~Told-target-pos transformq :inline :offset-assert 192) +; ) +; :method-count-assert 23 +; :size-assert #xf0 +; :flag-assert #x17008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; village3-obs +; (deftype pistons (process-drawable) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; village3-obs +; (deftype gondolacables (process-drawable) +; () +; :method-count-assert 21 +; :size-assert #xb0 +; :flag-assert #x15004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; minecart +; (deftype minecartsteel (process-drawable) +; ((~Tindex int32 :offset-assert 176) +; (~Tanim basic :offset-assert 180) +; (~Tsync sync-info :inline :offset-assert 184) +; ) +; :method-count-assert 21 +; :size-assert #xc0 +; :flag-assert #x15005000c0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; miners +; (deftype minertall (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; miners +; (deftype minershort (process-taskable) +; ((~Tother-miner basic :offset-assert 380) +; ) +; :method-count-assert 53 +; :size-assert #x180 +; :flag-assert #x3501100180 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; miners +; (deftype cavegem (process-drawable) +; () +; :method-count-assert 21 +; :size-assert #xb0 +; :flag-assert #x15004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; assistant-village3 +; (deftype assistant-villagec (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; sage-village3 +; (deftype sage-villagec (process-taskable) +; ((~Tevilbro uint64 :offset-assert 384) +; (~Tevilsis uint64 :offset-assert 392) +; (~Tassistant basic :offset-assert 400) +; ) +; :method-count-assert 53 +; :size-assert #x194 +; :flag-assert #x3501300194 +; ;; inherited inpspect of process-taskable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; cave-trap +; (deftype cave-trap (process-drawable) +; ((~Tspider-count int32 :offset-assert 176) +; (~Talt-actors basic :offset-assert 180) +; (~Tspawn-delay uint64 :offset-assert 184) +; (~Tlast-spawn-time uint64 :offset-assert 192) +; (~Tdebug-targ-pos vector :inline :offset-assert 208) +; ) +; :method-count-assert 21 +; :size-assert #xe0 +; :flag-assert #x15007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; cave-trap +; (deftype spider-vent (process-drawable) +; ((~Tlast-spawn-time uint64 :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb8 +; :flag-assert #x14005000b8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; cave-trap +; (deftype spawn-baby-spider-best (structure) +; ((index int32 :offset-assert 0) +; (dist float :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; cave-trap +; (deftype spawn-baby-spider-work (structure) +; ((best UNKNOWN 4 :offset-assert 0) +; ) +; :method-count-assert 9 +; :size-assert #x40 +; :flag-assert #x900000040 +; ) + +; ;; spider-egg +; (deftype spider-egg (process-drawable) +; ((~Tnotify-actor basic :offset-assert 176) +; (~Tbroken-look lod-set :inline :offset-assert 180) +; ) +; :method-count-assert 20 +; :size-assert #xd5 +; :flag-assert #x14007000d5 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; robocave-part +; (deftype robocave-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; target-snowball +; (deftype snowball-info (basic) +; ((entity basic :offset-assert 4) +; ) +; :method-count-assert 9 +; :size-assert #x8 +; :flag-assert #x900000008 +; ) + +; ;; target-snowball +; (deftype snowball-bank (basic) +; () +; :method-count-assert 9 +; :size-assert #x4 +; :flag-assert #x900000004 +; ) + +; ;; ice-cube +; (deftype ice-cube (nav-enemy) +; ((~Tpart2 basic :offset-assert 400) +; (~Tpart3 basic :offset-assert 404) +; (~Tpart4 basic :offset-assert 408) +; (~Ttrack-target? basic :offset-assert 412) +; (~Tslow-down? basic :offset-assert 416) +; (~Ttracking-player? basic :offset-assert 420) +; (~Tforce-spawn-pt int32 :offset-assert 424) +; (~Tspeed float :offset-assert 428) +; (~Tanim-blend float :offset-assert 432) +; (~Tprev-charge-angle-diff float :offset-assert 436) +; (~Tcharge-angle float :offset-assert 440) +; (~Tground-y float :offset-assert 444) +; (~Tcprims-type uint64 :offset-assert 448) +; (~Tnext-skid-sound-time uint64 :offset-assert 456) +; (~Tstarting-pos vector :inline :offset-assert 464) +; (~Ttarget-pt vector :inline :offset-assert 480) +; ) +; :method-count-assert 76 +; :size-assert #x1f0 +; :flag-assert #x4c018001f0 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; snow-ball +; (deftype snow-ball-shadow (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; snow-ball +; (deftype snow-ball-junction (structure) +; ((enter-time uint64 :offset-assert 0) +; (exit-time uint64 :offset-assert 8) +; ) +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +; ;; snow-ball +; (deftype snow-ball-path-info (structure) +; ((hug-path? basic :offset-assert 0) +; (path-pos vector :inline :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x20 +; :flag-assert #x900000020 +; ) + +; ;; snow-ball +; (deftype snow-ball-roller (process-drawable) +; ((~Twhich-path int32 :offset-assert 176) +; (~Tpath-u float :offset-assert 180) +; (~Tpath-speed float :offset-assert 184) +; (~Tpath-length float :offset-assert 188) +; (~Tpath-fall-u float :offset-assert 192) +; (~Tpath-coming-out-u float :offset-assert 196) +; (~Tpath-faded-up-u float :offset-assert 200) +; (~Tdelay-til-bounce int32 :offset-assert 204) +; (~Trolling-sound-id uint32 :offset-assert 208) +; (~Trolling-sound-enabled? basic :offset-assert 212) +; (~Tlast-bounce-time uint64 :offset-assert 216) +; (~Thit-player-time uint64 :offset-assert 224) +; (~Tpath-info snow-ball-path-info :inline :offset-assert 240) +; (~Tjunctions UNKNOWN 4 :offset-assert 272) +; ) +; :method-count-assert 23 +; :size-assert #x150 +; :flag-assert #x1700e00150 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; snow-ball +; (deftype snow-ball (process) +; ((~Tstate-time uint64 :offset-assert 112) +; (~Tlast-path-picked int32 :offset-assert 120) +; (~Tsame-path-picked-count int32 :offset-assert 124) +; (~Tdelay-til-next int32 :offset-assert 128) +; (~Tpath UNKNOWN 2 :offset-assert 132) +; ) +; :method-count-assert 16 +; :size-assert #x8c +; :flag-assert #x100020008c +; ;; inherited inpspect of process +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; ) +; ) + +; ;; snow-obs +; (deftype snowcam (pov-camera) +; ((~Tseq uint64 :offset-assert 224) +; ) +; :method-count-assert 30 +; :size-assert #xe8 +; :flag-assert #x1e008000e8 +; ;; inherited inpspect of pov-camera +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; snow-obs +; (deftype snow-eggtop (process-drawable) +; ((~Tspawn-trans vector :inline :offset-assert 176) +; (~Tplay-sound? basic :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xc4 +; :flag-assert #x14006000c4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; snow-obs +; (deftype snowpusher (process-drawable) +; ((~Tmax-frame float :offset-assert 176) +; (~Topen-sound uint128 :offset-assert 192) +; (~Tclose-sound uint128 :offset-assert 208) +; (~Tsync sync-info-paused :inline :offset-assert 224) +; ) +; :method-count-assert 20 +; :size-assert #xf0 +; :flag-assert #x14008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; snow-obs +; (deftype snow-spatula (baseplat) +; ((~Tsync sync-info :inline :offset-assert 228) +; (~Tstartmat matrix :inline :offset-assert 240) +; ) +; :method-count-assert 27 +; :size-assert #x130 +; :flag-assert #x1b00c00130 +; ;; inherited inpspect of baseplat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; ) +; ) + +; ;; snow-obs +; (deftype snow-fort-gate (process-drawable) +; ((~Tpart2 basic :offset-assert 176) +; (~Tpart3 basic :offset-assert 180) +; (~Topen-trans vector :inline :offset-assert 192) +; (~Tclosed-trans vector :inline :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xe0 +; :flag-assert #x14007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; snow-obs +; (deftype snow-gears (process-drawable) +; () +; :method-count-assert 21 +; :size-assert #xb0 +; :flag-assert #x15004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; snow-obs +; (deftype snow-switch (process-drawable) +; ((~Tpressed? basic :offset-assert 176) +; (~Tfcell-handle uint64 :offset-assert 184) +; (~Torig-trans vector :inline :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xd0 +; :flag-assert #x14006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; snow-obs +; (deftype snow-log (process-drawable) +; ((~Tmaster basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; snow-obs +; (deftype snow-log-button (process-drawable) +; ((~Tlog basic :offset-assert 176) +; (~Torig-trans vector :inline :offset-assert 192) +; ) +; :method-count-assert 20 +; :size-assert #xd0 +; :flag-assert #x14006000d0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; snow-flutflut-obs +; (deftype flutflut-plat (plat) +; ((~Thas-path? basic :offset-assert 264) +; (~Tplat-type int32 :offset-assert 268) +; (~Trise-time int32 :offset-assert 272) +; (~Tfall-time int32 :offset-assert 276) +; (~Tpart-ry float :offset-assert 280) +; (~Tsync-starting-val float :offset-assert 284) +; (~Tflutflut-button basic :offset-assert 288) +; (~Tappear-trans-top vector :inline :offset-assert 304) +; (~Tappear-trans-bottom vector :inline :offset-assert 320) +; (~Tappear-quat-top quaternion :inline :offset-assert 336) +; (~Tappear-quat-bottom quaternion :inline :offset-assert 352) +; (~Tstart-trans vector :inline :offset-assert 368) +; ) +; :method-count-assert 33 +; :size-assert #x180 +; :flag-assert #x2101100180 +; ;; inherited inpspect of plat +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; snow-flutflut-obs +; (deftype snow-button (process-drawable) +; ((~Twiggled? basic :offset-assert 176) +; (~Ttimeout uint64 :offset-assert 184) +; (~Tdelay-til-wiggle uint64 :offset-assert 192) +; (~Tprev-button basic :offset-assert 200) +; (~Tticker ticky :inline :offset-assert 208) +; ) +; :method-count-assert 20 +; :size-assert #xf0 +; :flag-assert #x14008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; snow-flutflut-obs +; (deftype flutflut-plat-small (flutflut-plat) +; () +; :method-count-assert 33 +; :size-assert #x180 +; :flag-assert #x2101100180 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; snow-flutflut-obs +; (deftype flutflut-plat-med (flutflut-plat) +; () +; :method-count-assert 33 +; :size-assert #x180 +; :flag-assert #x2101100180 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; snow-flutflut-obs +; (deftype flutflut-plat-large (flutflut-plat) +; () +; :method-count-assert 33 +; :size-assert #x180 +; :flag-assert #x2101100180 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; ) +; ) + +; ;; snow-bumper +; (deftype snow-bumper (process-drawable) +; ((~Tbumper-id int32 :offset-assert 176) +; (~Tbase-shove-ry float :offset-assert 180) +; (~Tmax-shove-diff-ry float :offset-assert 184) +; (~Tpart2 basic :offset-assert 188) +; (~Tlast-shoved-player-time uint64 :offset-assert 192) +; ) +; :method-count-assert 22 +; :size-assert #xc8 +; :flag-assert #x16006000c8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; snow-ram-h +; (deftype ram (process-drawable) +; ((~Tram-id int32 :offset-assert 176) +; (~Tgive-fuel-cell? basic :offset-assert 180) +; (~Tgive-fuel-cell-anim basic :offset-assert 184) +; (~Tpart2 basic :offset-assert 188) +; (~Torient-ry float :offset-assert 192) +; (~Tfuel-cell-dest-pos vector :inline :offset-assert 208) +; ) +; :method-count-assert 23 +; :size-assert #xe0 +; :flag-assert #x17007000e0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; ) +; ) + +; ;; snow-ram-boss +; (deftype ram-boss-proj (projectile) +; ((~Tpart2 basic :offset-assert 412) +; (~Tlaunched? basic :offset-assert 416) +; (~Tgrowth float :offset-assert 420) +; (~Tcharge-sound-id uint32 :offset-assert 424) +; (~Tlaunch-time uint64 :offset-assert 432) +; (~Tfacing-dir vector :inline :offset-assert 448) +; ) +; :method-count-assert 29 +; :size-assert #x1d0 +; :flag-assert #x1d016001d0 +; ;; inherited inpspect of projectile +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; ) +; ) + +; ;; snow-ram-boss +; (deftype ram-boss (nav-enemy) +; ((~Tfacing-y float :offset-assert 400) +; (~Tplayer-dir-y float :offset-assert 404) +; (~Tlast-turn-speed float :offset-assert 408) +; (~Tfrustration int32 :offset-assert 412) +; (~Tdead? basic :offset-assert 416) +; (~Thas-shield? basic :offset-assert 420) +; (~Tproj-stoked basic :offset-assert 424) +; (~Tproj-status uint64 :offset-assert 432) +; (~Tpart2 basic :offset-assert 440) +; (~Tproj-last-thrown-time uint64 :offset-assert 448) +; (~Tnav-enemy-patrol-timeout uint64 :offset-assert 456) +; (~Tproj-launch-vec vector :inline :offset-assert 464) +; (~Tlocal-throw-point vector :inline :offset-assert 480) +; (~Tshield-jmod basic :offset-assert 496) +; ) +; :method-count-assert 76 +; :size-assert #x1f4 +; :flag-assert #x4c019001f4 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; snow-part +; (deftype snow-part (part-spawner) +; () +; :method-count-assert 21 +; :size-assert #xd0 +; :flag-assert #x15006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; yeti +; (deftype yeti-slave (nav-enemy) +; ((~Tground-y float :offset-assert 400) +; (~Tpart2 basic :offset-assert 404) +; ) +; :method-count-assert 76 +; :size-assert #x198 +; :flag-assert #x4c01300198 +; ;; inherited inpspect of nav-enemy +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; (dummy-53 () none 53) +; (dummy-54 () none 54) +; (dummy-55 () none 55) +; (dummy-56 () none 56) +; (dummy-57 () none 57) +; (dummy-58 () none 58) +; (dummy-59 () none 59) +; (dummy-60 () none 60) +; (dummy-61 () none 61) +; (dummy-62 () none 62) +; (dummy-63 () none 63) +; (dummy-64 () none 64) +; (dummy-65 () none 65) +; (dummy-66 () none 66) +; (dummy-67 () none 67) +; (dummy-68 () none 68) +; (dummy-69 () none 69) +; (dummy-70 () none 70) +; (dummy-71 () none 71) +; (dummy-72 () none 72) +; (dummy-73 () none 73) +; (dummy-74 () none 74) +; (dummy-75 () none 75) +; ) +; ) + +; ;; yeti +; (deftype yeti (process-drawable) +; ((~Tdesired-num-children int32 :offset-assert 176) +; (~Tspawn-delay int32 :offset-assert 180) +; (~Tfirst-time-spawn-dist float :offset-assert 184) +; (~Tstate-time uint64 :offset-assert 168) +; ) +; :method-count-assert 22 +; :size-assert #xc8 +; :flag-assert #x16006000c8 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; lavatube-obs +; (deftype lavabase (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-obs +; (deftype lavafall (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-obs +; (deftype lavashortcut (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-obs +; (deftype darkecobarrel-leak (structure) +; ((offset vector :inline :offset-assert 0) +; (first-frame basic :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x14 +; :flag-assert #x900000014 +; ) + +; ;; lavatube-obs +; (deftype darkecobarrel-base (process-drawable) +; ((~Tspeed float :offset-assert 176) +; (~Tsync uint64 :offset-assert 184) +; ) +; :method-count-assert 20 +; :size-assert #xc0 +; :flag-assert #x14005000c0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-obs +; (deftype darkecobarrel-mover (darkecobarrel-base) +; ((~Tstart-time uint64 :offset-assert 192) +; (~Thits int32 :offset-assert 200) +; (~Tleak UNKNOWN 1 :offset-assert 208) +; (~Ty-offset bouncing-float :inline :offset-assert 240) +; (~Ty-offset-tgt delayed-rand-float :inline :offset-assert 280) +; (~Tdown oscillating-vector :inline :offset-assert 320) +; (~Tdown-tgt delayed-rand-vector :inline :offset-assert 384) +; ) +; :method-count-assert 20 +; :size-assert #x1b0 +; :flag-assert #x14014001b0 +; ;; inherited inpspect of darkecobarrel-base +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-obs +; (deftype darkecobarrel (darkecobarrel-base) +; ((~Tspawn-array basic :offset-assert 192) +; (~Tcur-spawn int32 :offset-assert 196) +; ) +; :method-count-assert 20 +; :size-assert #xc8 +; :flag-assert #x14006000c8 +; ;; inherited inpspect of darkecobarrel-base +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-obs +; (deftype lavafallsewera (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-obs +; (deftype lavafallsewerb (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-obs +; (deftype chainmine (process-drawable) +; () +; :method-count-assert 22 +; :size-assert #xb0 +; :flag-assert #x16004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; lavatube-obs +; (deftype lavaballoon (process-drawable) +; ((~Tmove-per-tick float :offset-assert 176) +; ) +; :method-count-assert 22 +; :size-assert #xb4 +; :flag-assert #x16005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; ) +; ) + +; ;; lavatube-obs +; (deftype lavatube-lava (water-anim) +; () +; :method-count-assert 30 +; :size-assert #xdc +; :flag-assert #x1e007000dc +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; ) +; ) + +; ;; lavatube-obs +; (deftype lavayellowtarp (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-energy +; (deftype energydoor (process-drawable) +; ((~Talt-actor basic :offset-assert 176) +; ) +; :method-count-assert 20 +; :size-assert #xb4 +; :flag-assert #x14005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-energy +; (deftype energybase (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-energy +; (deftype energyhub (process-drawable) +; ((~Talts UNKNOWN 3 :offset-assert 176) +; (~Tarm UNKNOWN 5 :offset-assert 192) +; (~Trot-mat matrix :inline :offset-assert 240) +; (~Trot-mat-init matrix :inline :offset-assert 304) +; (~Trotation-speed oscillating-float :inline :offset-assert 368) +; (~Trotation-speed-offset delayed-rand-float :inline :offset-assert 392) +; (~Ty-rotation float :offset-assert 420) +; (~Tx-rotation float :offset-assert 424) +; (~Tpalette-val float :offset-assert 428) +; ) +; :method-count-assert 20 +; :size-assert #x1b0 +; :flag-assert #x14014001b0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-energy +; (deftype energyarm (process-drawable) +; ((~Toffset vector :inline :offset-assert 176) +; (~Ty-rotation float :offset-assert 192) +; (~Ty-chatter-rotation bouncing-float :inline :offset-assert 196) +; (~Ty-chatter-min delayed-rand-float :inline :offset-assert 240) +; (~Tx-rotation bouncing-float :inline :offset-assert 268) +; (~Tx-fall-rotation bouncing-float :inline :offset-assert 308) +; (~Trot-mat matrix :inline :offset-assert 352) +; (~Tball uint64 :offset-assert 416) +; (~Tx-correction float :offset-assert 424) +; ) +; :method-count-assert 20 +; :size-assert #x1ac +; :flag-assert #x14014001ac +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-energy +; (deftype energyball (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-energy +; (deftype energylava (process-drawable) +; () +; :method-count-assert 20 +; :size-assert #xb0 +; :flag-assert #x14004000b0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; ) +; ) + +; ;; lavatube-part +; (deftype lavatube-part (UNKNOWN) +; () +; :method-count-assert 0 +; :size-assert #x0 +; :flag-assert #x0 +; ;; not enough basic ops +; ) + +; ;; assistant-lavatube +; (deftype assistant-lavatube-start (process-taskable) +; () +; :method-count-assert 53 +; :size-assert #x17c +; :flag-assert #x350110017c +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; (dummy-28 () none 28) +; (dummy-29 () none 29) +; (dummy-30 () none 30) +; (dummy-31 () none 31) +; (dummy-32 () none 32) +; (dummy-33 () none 33) +; (dummy-34 () none 34) +; (dummy-35 () none 35) +; (dummy-36 () none 36) +; (dummy-37 () none 37) +; (dummy-38 () none 38) +; (dummy-39 () none 39) +; (dummy-40 () none 40) +; (dummy-41 () none 41) +; (dummy-42 () none 42) +; (dummy-43 () none 43) +; (dummy-44 () none 44) +; (dummy-45 () none 45) +; (dummy-46 () none 46) +; (dummy-47 () none 47) +; (dummy-48 () none 48) +; (dummy-49 () none 49) +; (dummy-50 () none 50) +; (dummy-51 () none 51) +; (dummy-52 () none 52) +; ) +; ) + +; ;; title-obs +; (deftype logo (process-drawable) +; ((~Tcamera uint64 :offset-assert 176) +; (~Tcamera-anim uint64 :offset-assert 184) +; (~Tvolumes uint64 :offset-assert 192) +; (~Tblack uint64 :offset-assert 200) +; (~Ttarget uint64 :offset-assert 208) +; (~Tsidekick uint64 :offset-assert 216) +; (~Tmain-joint basic :offset-assert 224) +; (~Tanim basic :offset-assert 228) +; (~Tnext-anim basic :offset-assert 232) +; (~Tdone? basic :offset-assert 236) +; ) +; :method-count-assert 24 +; :size-assert #xf0 +; :flag-assert #x18008000f0 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; ) +; ) + +; ;; title-obs +; (deftype logo-slave (process-drawable) +; ((~Tmain-joint basic :offset-assert 176) +; ) +; :method-count-assert 21 +; :size-assert #xb4 +; :flag-assert #x15005000b4 +; ;; inherited inpspect of process-drawable +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; ) +; ) + +; ;; lava +; (deftype lava (water-anim) +; () +; :method-count-assert 28 +; :size-assert #xd0 +; :flag-assert #x1c006000d0 +; ;; not enough basic ops +; (:methods +; (dummy-9 () none 9) +; (dummy-10 () none 10) +; (dummy-11 () none 11) +; (dummy-12 () none 12) +; (dummy-13 () none 13) +; (dummy-14 () none 14) +; (dummy-15 () none 15) +; (dummy-16 () none 16) +; (dummy-17 () none 17) +; (dummy-18 () none 18) +; (dummy-19 () none 19) +; (dummy-20 () none 20) +; (dummy-21 () none 21) +; (dummy-22 () none 22) +; (dummy-23 () none 23) +; (dummy-24 () none 24) +; (dummy-25 () none 25) +; (dummy-26 () none 26) +; (dummy-27 () none 27) +; ) +; ) + + + + + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; SYMBOLS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff --git a/decompiler/config/jak1_ntsc_black_label.jsonc b/decompiler/config/jak1_ntsc_black_label.jsonc index c8748a67dc..487f27da99 100644 --- a/decompiler/config/jak1_ntsc_black_label.jsonc +++ b/decompiler/config/jak1_ntsc_black_label.jsonc @@ -3,14 +3,14 @@ { "game_version":1, // the order here matters. KERNEL and GAME should go first - "dgo_names":["CGO/KERNEL.CGO","CGO/GAME.CGO"], /* - , "CGO/ENGINE.CGO" + "dgo_names":["CGO/KERNEL.CGO","CGO/GAME.CGO", + "CGO/ENGINE.CGO" , "CGO/ART.CGO", "DGO/BEA.DGO", "DGO/CIT.DGO", "CGO/COMMON.CGO", "DGO/DAR.DGO", "DGO/DEM.DGO", "DGO/FIN.DGO", "DGO/INT.DGO", "DGO/JUB.DGO", "DGO/JUN.DGO", "CGO/JUNGLE.CGO", "CGO/L1.CGO", "DGO/FIC.DGO", "DGO/LAV.DGO", "DGO/MAI.DGO", "CGO/MAINCAVE.CGO", "DGO/MIS.DGO", "DGO/OGR.DGO", "CGO/RACERP.CGO", "DGO/ROB.DGO", "DGO/ROL.DGO", "DGO/SNO.DGO", "DGO/SUB.DGO", "DGO/SUN.DGO", "CGO/SUNKEN.CGO", "DGO/SWA.DGO", "DGO/TIT.DGO", "DGO/TRA.DGO", "DGO/VI1.DGO", "DGO/VI2.DGO", "DGO/VI3.DGO", "CGO/VILLAGEP.CGO", "CGO/WATER-AN.CGO" - ],*/ + ], "write_disassembly":true, "write_hex_near_instructions":false, @@ -34,7 +34,8 @@ "types_with_bad_inspect_methods":[ "engine", "bsp-header", - "joint-anim-matrix" + "joint-anim-matrix", + "part-tracker" ], "asm_functions_by_name":[ diff --git a/decompiler/util/DecompilerTypeSystem.cpp b/decompiler/util/DecompilerTypeSystem.cpp index f6ffdea4e3..706e6a820e 100644 --- a/decompiler/util/DecompilerTypeSystem.cpp +++ b/decompiler/util/DecompilerTypeSystem.cpp @@ -58,6 +58,19 @@ void DecompilerTypeSystem::parse_type_defs(const std::vector& file_ } else if (car(o).as_symbol()->name == "deftype") { parse_deftype(cdr(o), &ts); + } else if (car(o).as_symbol()->name == "declare-type") { + auto* rest = &cdr(o); + auto type_name = car(*rest); + rest = &cdr(*rest); + auto type_kind = car(*rest); + if (!cdr(*rest).is_empty_list()) { + throw std::runtime_error("malformed declare-type"); + } + if (type_kind.as_symbol()->name == "basic") { + ts.forward_declare_type_as_basic(type_name.as_symbol()->name); + } else { + throw std::runtime_error("bad declare-type"); + } } else { throw std::runtime_error("Decompiler cannot parse " + car(o).print()); } From a198196842b8188b13a9f7680756359656eb769b Mon Sep 17 00:00:00 2001 From: water Date: Sun, 25 Oct 2020 13:21:27 -0400 Subject: [PATCH 2/3] more types --- decompiler/Function/TypeInspector.cpp | 4 +- decompiler/config/all-types.gc | 5362 ++++++++++++------------- 2 files changed, 2603 insertions(+), 2763 deletions(-) diff --git a/decompiler/Function/TypeInspector.cpp b/decompiler/Function/TypeInspector.cpp index 10dd9a3348..93f375c311 100644 --- a/decompiler/Function/TypeInspector.cpp +++ b/decompiler/Function/TypeInspector.cpp @@ -356,7 +356,6 @@ int get_start_idx(Function& function, auto& get_format_op = function.basic_ops.at(1); if (is_get_sym_value(get_format_op.get(), make_gpr(Reg::T9), "format")) { - auto& get_true = function.basic_ops.at(2); if (!is_get_sym(get_true.get(), make_gpr(Reg::A0), "#t")) { result->warnings += "bad get true"; @@ -428,7 +427,8 @@ int get_start_idx(Function& function, return 5; } else { - result->warnings += "unrecognized get op: " + get_format_op->print(file) + " parent was " + parent_type; + result->warnings += + "unrecognized get op: " + get_format_op->print(file) + " parent was " + parent_type; return 0; } } diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc index b1fa703274..8be0462c20 100644 --- a/decompiler/config/all-types.gc +++ b/decompiler/config/all-types.gc @@ -6,6 +6,14 @@ ;; TYPES ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; KERNEL TYPES ;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; + + ; ;; gcommon ; (deftype array (UNKNOWN) ; () @@ -344,6 +352,12 @@ :flag-assert #x900000010 ) +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; ENGINE TYPES ;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; + ;; math (deftype random-generator (basic) ((seed uint32 :offset-assert 4) @@ -415,6 +429,7 @@ (x int16 :offset 0) (y int16 :offset 2) ) + :pack-me :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 @@ -5474,6 +5489,7 @@ (mem-actual int32 :offset-assert 24) (file mc-file-info 4 :inline :offset-assert 28) ) + :pack-me :method-count-assert 9 :size-assert #x12c :flag-assert #x90000012c @@ -5733,15 +5749,15 @@ ; ) ; ) -; ;; prototype-h -; (deftype prototype-array-shrub-info (basic) -; ((prototype-inline-array-shrub basic :offset-assert 4) -; (wind-vectors uint32 :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; prototype-h +(deftype prototype-array-shrub-info (basic) + ((prototype-inline-array-shrub basic :offset-assert 4) + (wind-vectors uint32 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) ; ;; prototype-h ; (deftype prototype-bucket-tie (prototype-bucket) @@ -5784,54 +5800,52 @@ ; :flag-assert #x900000094 ; ) -; ;; prototype-h -; (deftype prototype-array-tie (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 -; (dummy-9 () none 9) -; ) -; ) +;; prototype-h +(deftype prototype-array-tie (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 + (dummy-9 () none 9) + ) + ) -; ;; prototype-h -; (deftype proxy-prototype-array-tie (basic) -; ((prototype-array-tie basic :offset-assert 4) -; (wind-vectors uint32 :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; prototype-h +(deftype proxy-prototype-array-tie (basic) + ((prototype-array-tie basic :offset-assert 4) + (wind-vectors uint32 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) -; ;; prototype-h -; (deftype instance (drawable) -; ((id int16 :offset-assert 4) -; (bsphere vector :inline :offset-assert 16) -; (bucket-index uint16 :offset-assert 6) -; (origin matrix4h :inline :offset-assert 32) -; (wind-index uint16 :offset-assert 62) -; ) -; :method-count-assert 18 -; :size-assert #x40 -; :flag-assert #x1200000040 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; ) -; ) +;; prototype-h +(deftype instance (drawable) + ((bucket-index uint16 :offset 6) + (origin matrix4h :inline :offset-assert 32) + (wind-index uint16 :offset 62) + ) + :method-count-assert 18 + :size-assert #x40 + :flag-assert #x1200000040 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) ; ;; joint-h ; (deftype joint-control-channel (structure) @@ -5957,16 +5971,16 @@ ; :flag-assert #x900000020 ; ) -; ;; bones-h -; (deftype bone-regs (structure) -; ((joint-ptr uint32 :offset-assert 0) -; (bone-ptr uint32 :offset-assert 4) -; (num-bones uint32 :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; bones-h +(deftype bone-regs (structure) + ((joint-ptr uint32 :offset-assert 0) + (bone-ptr uint32 :offset-assert 4) + (num-bones uint32 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) ; ;; bones-h ; (deftype bone-work (structure) @@ -6011,16 +6025,16 @@ ; :flag-assert #x9000024f0 ; ) -; ;; bones-h -; (deftype merc-globals (structure) -; ((first uint32 :offset-assert 0) -; (next uint32 :offset-assert 4) -; (sink basic :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; bones-h +(deftype merc-globals (structure) + ((first uint32 :offset-assert 0) + (next uint32 :offset-assert 4) + (sink basic :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) ; ;; bones-h ; (deftype merc-global-array (structure) @@ -6032,18 +6046,18 @@ ; :flag-assert #x900000084 ; ) -; ;; bones-h -; (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 -; ) +;; bones-h +(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 + ) ;; res-h (deftype res-lump (basic) @@ -6390,32 +6404,32 @@ ; ) ; ) -; ;; game-h -; (deftype attack-info (structure) -; ((trans vector :inline :offset-assert 0) -; (vector vector :inline :offset-assert 16) -; (intersection vector :inline :offset-assert 32) -; (attacker handle :offset-assert 48) -; (invinc-time uint64 :offset-assert 56) -; (mask uint32 :offset-assert 64) -; (mode basic :offset-assert 68) -; (shove-back meters :offset-assert 72) -; (shove-up meters :offset-assert 76) -; (speed meters :offset-assert 80) -; (dist meters :offset-assert 84) -; (control float :offset-assert 88) -; (angle basic :offset-assert 92) -; (rotate-to deg :offset-assert 96) -; (prev-state basic :offset-assert 100) -; ) -; :method-count-assert 10 -; :size-assert #x68 -; :flag-assert #xa00000068 -; ;; field handle is likely a value type -; (:methods -; (dummy-9 () none 9) -; ) -; ) +;; game-h +(deftype attack-info (structure) + ((trans vector :inline :offset-assert 0) + (vector vector :inline :offset-assert 16) + (intersection vector :inline :offset-assert 32) + (attacker uint64 :offset-assert 48) ;; handle + (invinc-time uint64 :offset-assert 56) + (mask uint32 :offset-assert 64) + (mode basic :offset-assert 68) + (shove-back float :offset-assert 72) ;; meters + (shove-up float :offset-assert 76) ;; meters + (speed float :offset-assert 80) ;; meters + (dist float :offset-assert 84) ;; meters + (control float :offset-assert 88) + (angle basic :offset-assert 92) + (rotate-to float :offset-assert 96) ;; deg + (prev-state basic :offset-assert 100) + ) + :method-count-assert 10 + :size-assert #x68 + :flag-assert #xa00000068 + ;; field handle is likely a value type + (:methods + (dummy-9 () none 9) + ) + ) ; ;; game-h ; (deftype ground-tween-info (structure) @@ -6465,32 +6479,22 @@ ; ) ; ) -; ;; generic-obs-h -; (deftype part-spawner (process-drawable) -; ((~Tmode uint32 :offset-assert 176) -; (~Tenable basic :offset-assert 180) -; (~Tradius meters :offset-assert 184) -; (~Tworld-sphere sphere :inline :offset-assert 192) -; ) -; :method-count-assert 21 -; :size-assert #xd0 -; :flag-assert #x15006000d0 -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; ) -; ) +;; generic-obs-h +(deftype part-spawner (process-drawable) + ((~Tmode uint32 :offset-assert 176) + (~Tenable basic :offset-assert 180) + (~Tradius float :offset-assert 184) ; meters + (~Tworld-sphere sphere :inline :offset-assert 192) + ) + :heap-base #x60 + :method-count-assert 21 + :size-assert #xd0 + :flag-assert #x15006000d0 + ;; inherited inpspect of process-drawable + (:methods + (dummy-20 () none 20) + ) + ) ; ;; generic-obs-h ; (deftype part-tracker (process) @@ -6508,450 +6512,379 @@ ; ) ; ) -; ;; generic-obs-h -; (deftype camera-tracker (process) -; ((~Tname basic :offset-assert 4) -; (~Tgrab-target uint64 :offset-assert 120) -; (~Tgrab-event basic :offset-assert 128) -; (~Trelease-event basic :offset-assert 132) -; (~Told-global-mask uint32 :offset-assert 136) -; (~Told-self-mask uint32 :offset-assert 140) -; (~Told-parent-mask uint32 :offset-assert 144) -; (~Tlook-at-target uint64 :offset-assert 152) -; (~Tpov-target uint64 :offset-assert 160) -; (~Twork-process uint64 :offset-assert 168) -; (~Tanim-process uint64 :offset-assert 176) -; (~Tstart-time uint64 :offset-assert 184) -; (~Tcallback basic :offset-assert 192) -; (~Tuserdata basic :offset-assert 196) -; (~Tmessage basic :offset-assert 200) -; (~Tborder-value basic :offset-assert 204) -; (~Tmask-to-clear uint32 :offset-assert 208) -; (~Tscript basic :offset-assert 212) -; (~Tscript-line basic :offset-assert 216) -; (~Tscript-func basic :offset-assert 220) -; ) -; :method-count-assert 15 -; :size-assert #xe0 -; :flag-assert #xf007000e0 -; ;; inherited inpspect of processfield ~Tuserdata is a basic loaded with a signed load -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; ) -; ) +;; generic-obs-h +(deftype camera-tracker (process) + ( + ;(~Tname basic :offset-assert 4) + (~Tgrab-target uint64 :offset 120) + (~Tgrab-event basic :offset-assert 128) + (~Trelease-event basic :offset-assert 132) + (~Told-global-mask uint32 :offset-assert 136) + (~Told-self-mask uint32 :offset-assert 140) + (~Told-parent-mask uint32 :offset-assert 144) + (~Tlook-at-target uint64 :offset-assert 152) + (~Tpov-target uint64 :offset-assert 160) + (~Twork-process uint64 :offset-assert 168) + (~Tanim-process uint64 :offset-assert 176) + (~Tstart-time uint64 :offset-assert 184) + (~Tcallback basic :offset-assert 192) + (~Tuserdata basic :offset-assert 196) + (~Tmessage basic :offset-assert 200) + (~Tborder-value basic :offset-assert 204) + (~Tmask-to-clear uint32 :offset-assert 208) + (~Tscript basic :offset-assert 212) + (~Tscript-line basic :offset-assert 216) + (~Tscript-func basic :offset-assert 220) + ) + :heap-base #x70 + :method-count-assert 15 + :size-assert #xe0 + :flag-assert #xf007000e0 + ;; inherited inpspect of processfield ~Tuserdata is a basic loaded with a signed load + (:methods + (dummy-14 () none 14) + ) + ) -; ;; generic-obs-h -; (deftype touch-tracker (process-drawable) -; ((~Tduration uint64 :offset-assert 176) -; (~Ttarget uint64 :offset-assert 184) -; (~Tevent basic :offset-assert 192) -; (~Trun-function basic :offset-assert 196) -; (~Tcallback basic :offset-assert 200) -; (~Tevent-mode basic :offset-assert 204) -; ) -; :method-count-assert 20 -; :size-assert #xd0 -; :flag-assert #x14006000d0 -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; ) -; ) +;; generic-obs-h +(deftype touch-tracker (process-drawable) + ((~Tduration uint64 :offset-assert 176) + (~Ttarget uint64 :offset-assert 184) + (~Tevent basic :offset-assert 192) + (~Trun-function basic :offset-assert 196) + (~Tcallback basic :offset-assert 200) + (~Tevent-mode basic :offset-assert 204) + ) + :heap-base #x60 + :method-count-assert 20 + :size-assert #xd0 + :flag-assert #x14006000d0 + ;; inherited inpspect of process-drawable + ) -; ;; generic-obs-h -; (deftype swingpole (process) -; ((~Troot basic :offset-assert 112) -; (~Tdir vector :inline :offset-assert 128) -; (~Trange meters :offset-assert 144) -; (~Tedge-length meters :offset-assert 148) -; ) -; :method-count-assert 14 -; :size-assert #x98 -; :flag-assert #xe00300098 -; ;; inherited inpspect of process -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; ) -; ) +;; generic-obs-h +(deftype swingpole (process) + ((~Troot basic :offset-assert 112) + (~Tdir vector :inline :offset-assert 128) + (~Trange float :offset-assert 144) ;; meters + (~Tedge-length float :offset-assert 148) ;; meters + ) + :heap-base #x30 + :method-count-assert 14 + :size-assert #x98 + :flag-assert #xe00300098 + ;; inherited inpspect of process + ) -; ;; generic-obs-h -; (deftype gui-query (structure) -; ((x-position int32 :offset-assert 0) -; (y-position int32 :offset-assert 4) -; (message basic :offset-assert 8) -; (decision basic :offset-assert 12) -; (only-allow-cancel basic :offset-assert 16) -; (no-msg basic :offset-assert 20) -; (message-space int32 :offset-assert 24) -; ) -; :method-count-assert 11 -; :size-assert #x1c -; :flag-assert #xb0000001c -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) -; ) +;; generic-obs-h +(deftype gui-query (structure) + ((x-position int32 :offset-assert 0) + (y-position int32 :offset-assert 4) + (message basic :offset-assert 8) + (decision basic :offset-assert 12) + (only-allow-cancel basic :offset-assert 16) + (no-msg basic :offset-assert 20) + (message-space int32 :offset-assert 24) + ) + :pack-me + :method-count-assert 11 + :size-assert #x1c + :flag-assert #xb0000001c + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) -; ;; generic-obs-h -; (deftype othercam (process) -; ((~Thand uint64 :offset-assert 112) -; (~Told-global-mask uint32 :offset-assert 120) -; (~Tmask-to-clear uint32 :offset-assert 124) -; (~Tcam-joint-index int32 :offset-assert 128) -; (~Told-pos vector :inline :offset-assert 144) -; (~Told-mat-z vector :inline :offset-assert 160) -; (~Thad-valid-frame basic :offset-assert 176) -; (~Tborder-value basic :offset-assert 180) -; (~Tdie? basic :offset-assert 184) -; (~Tsurvive-anim-end? basic :offset-assert 188) -; (~Tspooling? basic :offset-assert 192) -; ) -; :method-count-assert 14 -; :size-assert #xc4 -; :flag-assert #xe006000c4 -; ;; inherited inpspect of process -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; ) -; ) +;; generic-obs-h +(deftype othercam (process) + ((~Thand uint64 :offset-assert 112) + (~Told-global-mask uint32 :offset-assert 120) + (~Tmask-to-clear uint32 :offset-assert 124) + (~Tcam-joint-index int32 :offset-assert 128) + (~Told-pos vector :inline :offset-assert 144) + (~Told-mat-z vector :inline :offset-assert 160) + (~Thad-valid-frame basic :offset-assert 176) + (~Tborder-value basic :offset-assert 180) + (~Tdie? basic :offset-assert 184) + (~Tsurvive-anim-end? basic :offset-assert 188) + (~Tspooling? basic :offset-assert 192) + ) + :heap-base #x60 + :method-count-assert 14 + :size-assert #xc4 + :flag-assert #xe006000c4 + ;; inherited inpspect of process + ) -; ;; generic-obs-h -; (deftype process-hidden (process) -; ((name basic :offset-assert 4) -; (mask uint32 :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) -; (state basic :offset-assert 56) -; (trans-hook basic :offset-assert 60) -; (post-hook basic :offset-assert 64) -; (event-hook basic :offset-assert 68) -; (allocated-length int32 :offset-assert 72) -; (next-state basic :offset-assert 76) -; (heap-base uint32 :offset-assert 80) -; (heap-top uint32 :offset-assert 84) -; (heap-cur uint32 :offset-assert 88) -; (stack-frame-top basic :offset-assert 92) -; (heap kheap :inline :offset-assert 80) -; (connection-list 'connectable :inline :offset-assert 96) -; (stack UNKNOWN :dynamic :offset-assert 112) -; ) -; :method-count-assert 15 -; :size-assert #x70 -; :flag-assert #xf00000070 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; ) -; ) +;; generic-obs-h +(deftype process-hidden (process) + () + :method-count-assert 15 + :size-assert #x70 + :flag-assert #xf00000070 + (:methods + (dummy-14 () none 14) + ) + ) -; ;; pov-camera-h -; (deftype pov-camera (process-drawable) -; ((~Tflags int32 :offset-assert 176) -; (~Tdebounce-start-time uint64 :offset-assert 184) -; (~Tnotify-handle uint64 :offset-assert 192) -; (~Tanim-name basic :offset-assert 200) -; (~Tcommand-list basic :offset-assert 204) -; (~Tmask-to-clear uint32 :offset-assert 208) -; (~Tmusic-volume-movie float :offset-assert 212) -; (~Tsfx-volume-movie float :offset-assert 216) -; ) -; :method-count-assert 30 -; :size-assert #xdc -; :flag-assert #x1e007000dc -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; (dummy-24 () none 24) -; (dummy-25 () none 25) -; (dummy-26 () none 26) -; (dummy-27 () none 27) -; (dummy-28 () none 28) -; (dummy-29 () none 29) -; ) -; ) +;; pov-camera-h +(deftype pov-camera (process-drawable) + ((~Tflags int32 :offset-assert 176) + (~Tdebounce-start-time uint64 :offset-assert 184) + (~Tnotify-handle uint64 :offset-assert 192) + (~Tanim-name basic :offset-assert 200) + (~Tcommand-list basic :offset-assert 204) + (~Tmask-to-clear uint32 :offset-assert 208) + (~Tmusic-volume-movie float :offset-assert 212) + (~Tsfx-volume-movie float :offset-assert 216) + ) + :heap-base #x70 + :method-count-assert 30 + :size-assert #xdc + :flag-assert #x1e007000dc + ;; inherited inpspect of process-drawable + (:methods + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + (dummy-27 () none 27) + (dummy-28 () none 28) + (dummy-29 () none 29) + ) + ) -; ;; sync-info-h -; (deftype sync-info (structure) -; ((offset float :offset-assert 0) -; (period uint32 :offset-assert 4) -; ) -; :method-count-assert 18 -; :size-assert #x8 -; :flag-assert #x1200000008 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; ) -; ) +;; sync-info-h +(deftype sync-info (structure) + ((offset float :offset-assert 0) + (period uint32 :offset-assert 4) + ) + :method-count-assert 18 + :size-assert #x8 + :flag-assert #x1200000008 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) -; ;; sync-info-h -; (deftype sync-info-eased (sync-info) -; ((offset float :offset-assert 0) -; (period uint32 :offset-assert 4) -; (tlo float :offset-assert 8) -; (thi float :offset-assert 12) -; (ylo float :offset-assert 16) -; (m2 float :offset-assert 20) -; (yend float :offset-assert 24) -; ) -; :method-count-assert 18 -; :size-assert #x1c -; :flag-assert #x120000001c -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; ) -; ) +;; sync-info-h +(deftype sync-info-eased (sync-info) + ((tlo float :offset-assert 8) + (thi float :offset-assert 12) + (ylo float :offset-assert 16) + (m2 float :offset-assert 20) + (yend float :offset-assert 24) + ) + :method-count-assert 18 + :size-assert #x1c + :flag-assert #x120000001c + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) -; ;; sync-info-h -; (deftype sync-info-paused (sync-info) -; ((offset float :offset-assert 0) -; (period uint32 :offset-assert 4) -; (pause-after-out float :offset-assert 8) -; (pause-after-in float :offset-assert 12) -; ) -; :method-count-assert 18 -; :size-assert #x10 -; :flag-assert #x1200000010 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; ) -; ) +;; sync-info-h +(deftype sync-info-paused (sync-info) + ((pause-after-out float :offset-assert 8) + (pause-after-in float :offset-assert 12) + ) + :method-count-assert 18 + :size-assert #x10 + :flag-assert #x1200000010 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) -; ;; sync-info-h -; (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) -; (value float :offset-assert 24) -; ) -; :method-count-assert 11 -; :size-assert #x1c -; :flag-assert #xb0000001c -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) -; ) +;; sync-info-h +(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) + (value float :offset-assert 24) + ) + :method-count-assert 11 + :size-assert #x1c + :flag-assert #xb0000001c + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) -; ;; sync-info-h -; (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 -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) -; ) +;; sync-info-h +(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 + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) -; ;; sync-info-h -; (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 -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; ) -; ) +;; sync-info-h +(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 + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) -; ;; sync-info-h -; (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) -; (value vector :inline :offset-assert 32) -; ) -; :method-count-assert 13 -; :size-assert #x30 -; :flag-assert #xd00000030 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; ) -; ) +;; sync-info-h +(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) + (value vector :inline :offset-assert 32) + ) + :method-count-assert 13 + :size-assert #x30 + :flag-assert #xd00000030 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) -; ;; sync-info-h -; (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 -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) -; ) +;; sync-info-h +(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 + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) -; ;; smush-control-h -; (deftype smush-control (structure) -; ((start-time uint64 :offset-assert 0) -; (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 -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; ) -; ) +;; smush-control-h +(deftype smush-control (structure) + ((start-time uint64 :offset-assert 0) + (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 + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + ) + ) -; ;; 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 16 -; :size-assert #x28 -; :flag-assert #x1000000028 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; ) -; ) + ;; 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 float :offset-assert 36) ;; meters + ) + :method-count-assert 16 + :size-assert #x28 + :flag-assert #x1000000028 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + ) + ) -; ;; debug-h -; (deftype pos-history (structure) -; ((points uint32 :offset-assert 0) -; (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 -; ) +;; debug-h +(deftype pos-history (structure) + ((points uint32 :offset-assert 0) + (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 + ) -; ;; debug-h -; (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 -; ) +;; debug-h +(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 + ) ; ;; debug-h ; (deftype debug-vertex-stats (basic) @@ -6964,114 +6897,114 @@ ; :flag-assert #x900004b10 ; ) -; ;; joint-mod-h -; (deftype joint-mod (basic) -; ((mode uint32 :offset-assert 4) -; (process basic :offset-assert 8) -; (joint cspace :offset-assert 12) -; (target vector :inline :offset-assert 16) -; (twist vector :inline :offset-assert 32) -; (twist-max vector :inline :offset-assert 48) -; (trans vector :inline :offset-assert 64) -; (quat quaternion :inline :offset-assert 80) -; (scale vector :inline :offset-assert 96) -; (notice-time uint64 :offset-assert 112) -; (flex-blend float :offset-assert 120) -; (blend float :offset-assert 124) -; (max-dist meters :offset-assert 128) -; (ignore-angle deg :offset-assert 132) -; (up uint8 :offset-assert 136) -; (nose uint8 :offset-assert 137) -; (ear uint8 :offset-assert 138) -; (shutting-down? basic :offset-assert 140) -; (parented-scale? basic :offset-assert 128) -; ) -; :method-count-assert 16 -; :size-assert #x90 -; :flag-assert #x1000000090 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; ) -; ) +;; joint-mod-h +(deftype joint-mod (basic) + ((mode uint32 :offset-assert 4) + (process basic :offset-assert 8) + (joint cspace :offset-assert 12) + (target vector :inline :offset-assert 16) + (twist vector :inline :offset-assert 32) + (twist-max vector :inline :offset-assert 48) + (trans vector :inline :offset-assert 64) + (quat quaternion :inline :offset-assert 80) + (scale vector :inline :offset-assert 96) + (notice-time uint64 :offset-assert 112) + (flex-blend float :offset-assert 120) + (blend float :offset-assert 124) + (max-dist float :offset-assert 128) ;; meters + (ignore-angle float :offset-assert 132) ;; deg + (up uint8 :offset-assert 136) + (nose uint8 :offset-assert 137) + (ear uint8 :offset-assert 138) + (shutting-down? basic :offset-assert 140) + (parented-scale? basic :offset 128) + ) + :method-count-assert 16 + :size-assert #x90 + :flag-assert #x1000000090 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + ) + ) -; ;; joint-mod-h -; (deftype try-to-look-at-info (basic) -; ((who uint64 :offset-assert 8) -; (horz float :offset-assert 16) -; (vert float :offset-assert 20) -; ) -; :method-count-assert 9 -; :size-assert #x18 -; :flag-assert #x900000018 -; ) +;; joint-mod-h +(deftype try-to-look-at-info (basic) + ((who uint64 :offset-assert 8) + (horz float :offset-assert 16) + (vert float :offset-assert 20) + ) + :method-count-assert 9 + :size-assert #x18 + :flag-assert #x900000018 + ) -; ;; joint-mod-h -; (deftype joint-mod-wheel (basic) -; ((last-position vector :inline :offset-assert 16) -; (angle float :offset-assert 32) -; (process basic :offset-assert 36) -; (wheel-radius float :offset-assert 40) -; (wheel-axis int8 :offset-assert 44) -; ) -; :method-count-assert 9 -; :size-assert #x2d -; :flag-assert #x90000002d -; ) +;; joint-mod-h +(deftype joint-mod-wheel (basic) + ((last-position vector :inline :offset-assert 16) + (angle float :offset-assert 32) + (process basic :offset-assert 36) + (wheel-radius float :offset-assert 40) + (wheel-axis int8 :offset-assert 44) + ) + :method-count-assert 9 + :size-assert #x2d + :flag-assert #x90000002d + ) -; ;; joint-mod-h -; (deftype joint-mod-set-local (basic) -; ((transform transformq :inline :offset-assert 16) -; (set-rotation basic :offset-assert 64) -; (set-scale basic :offset-assert 68) -; (set-translation basic :offset-assert 72) -; (enable basic :offset-assert 76) -; ) -; :method-count-assert 9 -; :size-assert #x50 -; :flag-assert #x900000050 -; ) +;; joint-mod-h +(deftype joint-mod-set-local (basic) + ((transform transformq :inline :offset-assert 16) + (set-rotation basic :offset-assert 64) + (set-scale basic :offset-assert 68) + (set-translation basic :offset-assert 72) + (enable basic :offset-assert 76) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) -; ;; joint-mod-h -; (deftype joint-mod-set-world (basic) -; ((transform transformq :inline :offset-assert 16) -; (node-index int32 :offset-assert 64) -; (enable basic :offset-assert 68) -; ) -; :method-count-assert 9 -; :size-assert #x48 -; :flag-assert #x900000048 -; ) +;; joint-mod-h +(deftype joint-mod-set-world (basic) + ((transform transformq :inline :offset-assert 16) + (node-index int32 :offset-assert 64) + (enable basic :offset-assert 68) + ) + :method-count-assert 9 + :size-assert #x48 + :flag-assert #x900000048 + ) -; ;; joint-mod-h -; (deftype joint-mod-blend-local (basic) -; ((transform transformq :inline :offset-assert 16) -; (blend-transform transformq :inline :offset-assert 64) -; (node-index int32 :offset-assert 112) -; (blend float :offset-assert 116) -; (enable basic :offset-assert 120) -; ) -; :method-count-assert 9 -; :size-assert #x7c -; :flag-assert #x90000007c -; ) +;; joint-mod-h +(deftype joint-mod-blend-local (basic) + ((transform transformq :inline :offset-assert 16) + (blend-transform transformq :inline :offset-assert 64) + (node-index int32 :offset-assert 112) + (blend float :offset-assert 116) + (enable basic :offset-assert 120) + ) + :method-count-assert 9 + :size-assert #x7c + :flag-assert #x90000007c + ) -; ;; joint-mod-h -; (deftype joint-mod-spinner (basic) -; ((spin-axis vector :inline :offset-assert 16) -; (angle float :offset-assert 32) -; (spin-rate float :offset-assert 36) -; (enable basic :offset-assert 40) -; ) -; :method-count-assert 9 -; :size-assert #x2c -; :flag-assert #x90000002c -; ) +;; joint-mod-h +(deftype joint-mod-spinner (basic) + ((spin-axis vector :inline :offset-assert 16) + (angle float :offset-assert 32) + (spin-rate float :offset-assert 36) + (enable basic :offset-assert 40) + ) + :method-count-assert 9 + :size-assert #x2c + :flag-assert #x90000002c + ) ; ;; collide-mesh-h ; (deftype collide-tri-result (structure) @@ -7147,20 +7080,20 @@ ; :flag-assert #x900000060 ; ) -; ;; collide-shape-h -; (deftype collide-sticky-rider (structure) -; ((rider-handle uint64 :offset-assert 0) -; (sticky-prim basic :offset-assert 8) -; (prim-ry float :offset-assert 12) -; (rider-local-pos vector :inline :offset-assert 16) -; ) -; :method-count-assert 10 -; :size-assert #x20 -; :flag-assert #xa00000020 -; (:methods -; (dummy-9 () none 9) -; ) -; ) +;; collide-shape-h +(deftype collide-sticky-rider (structure) + ((rider-handle uint64 :offset-assert 0) + (sticky-prim basic :offset-assert 8) + (prim-ry float :offset-assert 12) + (rider-local-pos vector :inline :offset-assert 16) + ) + :method-count-assert 10 + :size-assert #x20 + :flag-assert #xa00000020 + (:methods + (dummy-9 () none 9) + ) + ) ; ;; collide-shape-h ; (deftype collide-sticky-rider-group (basic) @@ -7177,17 +7110,17 @@ ; ) ; ) -; ;; collide-shape-h -; (deftype pull-rider-info (structure) -; ((rider collide-sticky-rider :offset-assert 0) -; (rider-cshape basic :offset-assert 4) -; (rider-delta-ry float :offset-assert 8) -; (rider-dest vector :inline :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 -; ) +;; collide-shape-h +(deftype pull-rider-info (structure) + ((rider collide-sticky-rider :offset-assert 0) + (rider-cshape basic :offset-assert 4) + (rider-delta-ry float :offset-assert 8) + (rider-dest vector :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) ; ;; collide-shape-h ; (deftype collide-shape-intersect (basic) @@ -7614,26 +7547,26 @@ ; ) ; ) -; ;; collide-target-h -; (deftype collide-history (structure) -; ((intersect vector :inline :offset-assert 0) -; (trans vector :inline :offset-assert 16) -; (transv vector :inline :offset-assert 32) -; (transv-out vector :inline :offset-assert 48) -; (local-normal vector :inline :offset-assert 64) -; (surface-normal vector :inline :offset-assert 80) -; (time uint64 :offset-assert 96) -; (status uint64 :offset-assert 104) -; (pat uint32 :offset-assert 112) -; (reaction-flag uint32 :offset-assert 116) -; ) -; :method-count-assert 10 -; :size-assert #x78 -; :flag-assert #xa00000078 -; (:methods -; (dummy-9 () none 9) -; ) -; ) +;; collide-target-h +(deftype collide-history (structure) + ((intersect vector :inline :offset-assert 0) + (trans vector :inline :offset-assert 16) + (transv vector :inline :offset-assert 32) + (transv-out vector :inline :offset-assert 48) + (local-normal vector :inline :offset-assert 64) + (surface-normal vector :inline :offset-assert 80) + (time uint64 :offset-assert 96) + (status uint64 :offset-assert 104) + (pat uint32 :offset-assert 112) + (reaction-flag uint32 :offset-assert 116) + ) + :method-count-assert 10 + :size-assert #x78 + :flag-assert #xa00000078 + (:methods + (dummy-9 () none 9) + ) + ) ; ;; collide-touch-h ; (deftype touching-prim (structure) @@ -7949,91 +7882,60 @@ ; ) ; ) -; ;; projectiles-h -; (deftype projectile (process-drawable) -; ((~Tbase-trans vector :inline :offset-assert 176) -; (~Ttarget vector :inline :offset-assert 192) -; (~Ttarget-base vector :inline :offset-assert 208) -; (~Tparent-base vector :inline :offset-assert 224) -; (~Tparent-quat vector :inline :offset-assert 240) -; (~Tbase-vector vector :inline :offset-assert 256) -; (~Ttimeout uint64 :offset-assert 272) -; (~Toptions uint64 :offset-assert 280) -; (~Tlast-target uint64 :offset-assert 288) -; (~Tnotify-handle uint64 :offset-assert 296) -; (~Tmax-speed float :offset-assert 304) -; (~Tmax-turn float :offset-assert 308) -; (~Told-dist UNKNOWN 16 :offset-assert 312) -; (~Told-dist-count int32 :offset-assert 376) -; (~Thits int32 :offset-assert 380) -; (~Tmax-hits int32 :offset-assert 384) -; (~Ttween float :offset-assert 388) -; (~Tattack-mode basic :offset-assert 392) -; (~Tupdate-velocity basic :offset-assert 396) -; (~Tcounter int32 :offset-assert 400) -; (~Ttarget-count int32 :offset-assert 404) -; (~Tsound-id uint32 :offset-assert 408) -; ) -; :method-count-assert 29 -; :size-assert #x19c -; :flag-assert #x1d0130019c -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; (dummy-24 () none 24) -; (dummy-25 () none 25) -; (dummy-26 () none 26) -; (dummy-27 () none 27) -; (dummy-28 () none 28) -; ) -; ) +;; projectiles-h +(deftype projectile (process-drawable) + ((~Tbase-trans vector :inline :offset-assert 176) + (~Ttarget vector :inline :offset-assert 192) + (~Ttarget-base vector :inline :offset-assert 208) + (~Tparent-base vector :inline :offset-assert 224) + (~Tparent-quat vector :inline :offset-assert 240) + (~Tbase-vector vector :inline :offset-assert 256) + (~Ttimeout uint64 :offset-assert 272) + (~Toptions uint64 :offset-assert 280) + (~Tlast-target uint64 :offset-assert 288) + (~Tnotify-handle uint64 :offset-assert 296) + (~Tmax-speed float :offset-assert 304) + (~Tmax-turn float :offset-assert 308) + (~Told-dist float 16 :offset-assert 312) + (~Told-dist-count int32 :offset-assert 376) + (~Thits int32 :offset-assert 380) + (~Tmax-hits int32 :offset-assert 384) + (~Ttween float :offset-assert 388) + (~Tattack-mode basic :offset-assert 392) + (~Tupdate-velocity basic :offset-assert 396) + (~Tcounter int32 :offset-assert 400) + (~Ttarget-count int32 :offset-assert 404) + (~Tsound-id uint32 :offset-assert 408) + ) + :heap-base #x130 + :method-count-assert 29 + :size-assert #x19c + :flag-assert #x1d0130019c + ;; inherited inpspect of process-drawable + (:methods + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + (dummy-27 () none 27) + (dummy-28 () none 28) + ) + ) -; ;; projectiles-h -; (deftype projectile-yellow (projectile) -; ((~Tmode int32 :offset-assert 412) -; (~Tangle float :offset-assert 416) -; ) -; :method-count-assert 29 -; :size-assert #x1a4 -; :flag-assert #x1d014001a4 -; ;; inherited inpspect of projectile -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; (dummy-24 () none 24) -; (dummy-25 () none 25) -; (dummy-26 () none 26) -; (dummy-27 () none 27) -; (dummy-28 () none 28) -; ) -; ) +;; projectiles-h +(deftype projectile-yellow (projectile) + ((~Tmode int32 :offset-assert 412) + (~Tangle float :offset-assert 416) + ) + :heap-base #x140 + :method-count-assert 29 + :size-assert #x1a4 + :flag-assert #x1d014001a4 + ;; inherited inpspect of projectile + ) ; ;; projectiles-h ; (deftype projectile-blue (projectile) @@ -8068,160 +7970,138 @@ ; ) ; ) -; ;; target-h -; (deftype target (process-drawable) -; ((~Tcontrol basic :offset-assert 112) -; (~Tskel2 basic :offset-assert 176) -; (~Tracer basic :offset-assert 180) -; (~Tgame basic :offset-assert 184) -; (~Tneck basic :offset-assert 188) -; (~Tstate-hook-time uint64 :offset-assert 192) -; (~Tstate-hook basic :offset-assert 200) -; (~Tcam-user-mode basic :offset-assert 204) -; (~Tsidekick uint32 :offset-assert 208) -; (~Tmanipy uint32 :offset-assert 212) -; (~Tattack-info attack-info :inline :offset-assert 224) -; (~Tattack-info-rec attack-info :inline :offset-assert 336) -; (~Tanim-seed uint64 :offset-assert 440) -; (~Talt-cam-pos vector :inline :offset-assert 448) -; (~Tsnowball basic :offset-assert 464) -; (~Ttube basic :offset-assert 468) -; (~Tflut basic :offset-assert 472) -; (~Tcurrent-level basic :offset-assert 476) -; (~Tsaved-pos transformq :inline :offset-assert 480) -; (~Tsaved-owner uint64 :offset-assert 528) -; (~Talt-neck-pos vector :inline :offset-assert 544) -; (~Tfp-hud uint64 :offset-assert 560) -; (~Tno-load-wait uint64 :offset-assert 568) -; (~Tno-look-around-wait uint64 :offset-assert 576) -; ) -; :method-count-assert 21 -; :size-assert #x248 -; :flag-assert #x1501e00248 -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; ) -; ) +;; target-h +(deftype target (process-drawable) + ((~Tcontrol basic :offset 112) + (~Tskel2 basic :offset-assert 176) + (~Tracer basic :offset-assert 180) + (~Tgame basic :offset-assert 184) + (~Tneck basic :offset-assert 188) + (~Tstate-hook-time uint64 :offset-assert 192) + (~Tstate-hook basic :offset-assert 200) + (~Tcam-user-mode basic :offset-assert 204) + (~Tsidekick uint32 :offset-assert 208) + (~Tmanipy uint32 :offset-assert 212) + (~Tattack-info attack-info :inline :offset-assert 224) + (~Tattack-info-rec attack-info :inline :offset-assert 336) + (~Tanim-seed uint64 :offset-assert 440) + (~Talt-cam-pos vector :inline :offset-assert 448) + (~Tsnowball basic :offset-assert 464) + (~Ttube basic :offset-assert 468) + (~Tflut basic :offset-assert 472) + (~Tcurrent-level basic :offset-assert 476) + (~Tsaved-pos transformq :inline :offset-assert 480) + (~Tsaved-owner uint64 :offset-assert 528) + (~Talt-neck-pos vector :inline :offset-assert 544) + (~Tfp-hud uint64 :offset-assert 560) + (~Tno-load-wait uint64 :offset-assert 568) + (~Tno-look-around-wait uint64 :offset-assert 576) + ) + :heap-base #x1e0 + :method-count-assert 21 + :size-assert #x248 + :flag-assert #x1501e00248 + ;; inherited inpspect of process-drawable + (:methods + (dummy-20 () none 20) + ) + ) -; ;; target-h -; (deftype sidekick (process-drawable) -; ((~Tcontrol basic :offset-assert 112) -; (~Tstate-time uint64 :offset-assert 168) -; (~Tstate-flags uint32 :offset-assert 164) -; (~Tanim-seed uint64 :offset-assert 192) -; (~Tshadow-in-movie? basic :offset-assert 200) -; ) -; :method-count-assert 20 -; :size-assert #xcc -; :flag-assert #x14006000cc -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; ) -; ) +;; target-h +(deftype sidekick (process-drawable) + ((~Tcontrol basic :offset 112) + (~Tstate-time uint64 :offset 168) + (~Tstate-flags uint32 :offset 164) + (~Tanim-seed uint64 :offset 192) + (~Tshadow-in-movie? basic :offset-assert 200) + ) + :heap-base #x60 + :method-count-assert 20 + :size-assert #xcc + :flag-assert #x14006000cc + ;; inherited inpspect of process-drawable + ) -; ;; depth-cue-h -; (deftype depth-cue-data (structure) -; ((data vector :inline :offset-assert 0) -; (sharpness float :offset-assert 0) -; (alpha float :offset-assert 4) -; (distance float :offset-assert 8) -; (w float :offset-assert 12) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; depth-cue-h +(deftype depth-cue-data (structure) + ((data vector :inline :offset-assert 0) + (sharpness float :offset 0) + (alpha float :offset 4) + (distance float :offset 8) + (w float :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) -; ;; depth-cue-h -; (deftype depth-cue-work (structure) -; ((texture-strip-tmpl dma-gif-packet :inline :offset-assert 0) -; (temp-strip-tmpl dma-gif-packet :inline :offset-assert 32) -; (stencil-tmpl dma-gif-packet :inline :offset-assert 64) -; (clear-color vector4w :inline :offset-assert 96) -; (set-color vector4w :inline :offset-assert 112) -; (draw-color vector4w :inline :offset-assert 128) -; (depth depth-cue-data :offset-assert 144) -; (front depth-cue-data :offset-assert 148) -; ) -; :method-count-assert 9 -; :size-assert #x98 -; :flag-assert #x900000098 -; ) +;; depth-cue-h +(deftype depth-cue-work (structure) + ((texture-strip-tmpl dma-gif-packet :inline :offset-assert 0) + (temp-strip-tmpl dma-gif-packet :inline :offset-assert 32) + (stencil-tmpl dma-gif-packet :inline :offset-assert 64) + (clear-color vector4w :inline :offset-assert 96) + (set-color vector4w :inline :offset-assert 112) + (draw-color vector4w :inline :offset-assert 128) + (depth depth-cue-data :offset-assert 144) + (front depth-cue-data :offset-assert 148) + ) + :method-count-assert 9 + :size-assert #x98 + :flag-assert #x900000098 + ) -; ;; 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 -; ) +;; 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 + ) -; ;; stats-h -; (deftype merc-global-stats (structure) -; ((merc tr-stat :inline :offset-assert 0) -; (mercneric tr-stat :inline :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 -; ) +;; stats-h +(deftype merc-global-stats (structure) + ((merc tr-stat :inline :offset-assert 0) + (mercneric tr-stat :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) -; ;; stats-h -; (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 -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; ) -; ) +;; stats-h +(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 + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + ) + ) ; ;; stats-h ; (deftype perf-stat-array (inline-array-class) @@ -8234,43 +8114,43 @@ ; :flag-assert #x900000010 ; ) -; ;; bsp-h -; (deftype bsp-node (structure) -; ((front int32 :offset-assert 0) -; (back int32 :offset-assert 4) -; (front-flags uint32 :offset-assert 8) -; (back-flags uint32 :offset-assert 12) -; (plane vector :inline :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 -; ) +;; bsp-h +(deftype bsp-node (structure) + ((front int32 :offset-assert 0) + (back int32 :offset-assert 4) + (front-flags uint32 :offset-assert 8) + (back-flags uint32 :offset-assert 12) + (plane vector :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) -; ;; bsp-h -; (deftype game-level (basic) -; ((master-bsp basic :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #x8 -; :flag-assert #x900000008 -; ) +;; bsp-h +(deftype game-level (basic) + ((master-bsp basic :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) -; ;; bsp-h -; (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 -; ) +;; bsp-h +(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 + ) ; ;; bsp-h ; (deftype bsp-header (drawable) @@ -8293,18 +8173,19 @@ ; ) ; ) -; ;; bsp-h -; (deftype cl-stat (structure) -; ((fragments uint32 :offset-assert 0) -; (tris uint32 :offset-assert 4) -; (output uint32 :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; bsp-h +(deftype cl-stat (structure) + ((fragments uint32 :offset-assert 0) + (tris uint32 :offset-assert 4) + (output uint32 :offset-assert 8) + ) + :pack-me + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) -; ;; bsp-h +;; bsp-h ; (deftype collide-stats (structure) ; ((other cl-stat :inline :offset-assert 0) ; (total cl-stat :inline :offset-assert 12) @@ -8316,50 +8197,50 @@ ; ) ; :method-count-assert 9 ; :size-assert #x80 -; :flag-assert #x900000080 -; ) - -; ;; collide-cache-h -; (deftype collide-using-spheres-params (structure) -; ((spheres uint32 :offset-assert 0) -; (num-spheres uint32 :offset-assert 4) -; (collide-with uint64 :offset-assert 8) -; (proc basic :offset-assert 16) -; (ignore-pat uint32 :offset-assert 20) -; (solid-only basic :offset-assert 24) -; ) -; :method-count-assert 9 -; :size-assert #x1c -; :flag-assert #x90000001c -; ) - -; ;; 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 -; ) - -; ;; collide-cache-h -; (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 UNKNOWN 64 :offset-assert 96) -; ) -; :method-count-assert 11 -; :size-assert #xc60 -; :flag-assert #xb00000c60 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) +; :flag-assert #x900000080 ; ) +;; collide-cache-h +(deftype collide-using-spheres-params (structure) + ((spheres uint32 :offset-assert 0) + (num-spheres uint32 :offset-assert 4) + (collide-with uint64 :offset-assert 8) + (proc basic :offset-assert 16) + (ignore-pat uint32 :offset-assert 20) + (solid-only basic :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) + +;; 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 + ) + +;; collide-cache-h +(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 :inline :offset-assert 96) + ) + :method-count-assert 11 + :size-assert #xc60 + :flag-assert #xb00000c60 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) + ; ;; collide-cache-h ; (deftype collide-puyp-work (structure) ; ((best-u float :offset-assert 0) @@ -8454,58 +8335,56 @@ ; ) ; ) -; ;; collide-cache-h -; (deftype collide-list-item (structure) -; ((mesh basic :offset-assert 0) -; (inst basic :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #x8 -; :flag-assert #x900000008 -; ) +;; collide-cache-h +(deftype collide-list-item (structure) + ((mesh basic :offset-assert 0) + (inst basic :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) -; ;; collide-cache-h -; (deftype collide-list (structure) -; ((num-items int32 :offset-assert 0) -; (items UNKNOWN 256 :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x1010 -; :flag-assert #x900001010 -; ) +;; collide-cache-h +(deftype collide-list (structure) + ((num-items int32 :offset-assert 0) + (items collide-list-item 256 :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x1010 + :flag-assert #x900001010 + ) -; ;; collide-cache-h -; (deftype collide-work (structure) -; ((collide-sphere-neg-r sphere :inline :offset-assert 0) -; (collide-box4w bounding-box4w :inline :offset-assert 16) -; (inv-mat matrix :inline :offset-assert 48) -; ) -; :method-count-assert 9 -; :size-assert #x70 -; :flag-assert #x900000070 -; ) +;; collide-cache-h +(deftype collide-work (structure) + ((collide-sphere-neg-r sphere :inline :offset-assert 0) + (collide-box4w bounding-box4w :inline :offset-assert 16) + (inv-mat matrix :inline :offset-assert 48) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) -; ;; shrubbery-h -; (deftype billboard (drawable) -; ((id int16 :offset-assert 4) -; (bsphere vector :inline :offset-assert 16) -; (flat adgif-shader :inline :offset-assert 32) -; ) -; :method-count-assert 18 -; :size-assert #x70 -; :flag-assert #x1200000070 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; ) -; ) +;; shrubbery-h +(deftype billboard (drawable) + ((flat adgif-shader :inline :offset-assert 32) + ) + :method-count-assert 18 + :size-assert #x70 + :flag-assert #x1200000070 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) ; ;; shrubbery-h ; (deftype shrub-view-data (structure) @@ -8527,104 +8406,95 @@ ; :flag-assert #x900000030 ; ) -; ;; shrubbery-h -; (deftype shrubbery (drawable) -; ((id int16 :offset-assert 4) -; (bsphere vector :inline :offset-assert 16) -; (textures uint32 :offset-assert 4) -; (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 18 -; :size-assert #x20 -; :flag-assert #x1200000020 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; ) -; ) +;; shrubbery-h +(deftype shrubbery (drawable) + ((textures uint32 :offset 4) + (header qword :offset 8) + (obj-qwc uint8 :offset 12) + (vtx-qwc uint8 :offset 13) + (col-qwc uint8 :offset 14) + (stq-qwc uint8 :offset 15) + (obj uint32 :offset 16) + (vtx uint32 :offset 20) + (col uint32 :offset 24) + (stq uint32 :offset 28) + ) + :method-count-assert 18 + :size-assert #x20 + :flag-assert #x1200000020 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) -; ;; shrubbery-h -; (deftype instance-shrubbery (instance) -; ((id int16 :offset-assert 4) -; (bsphere vector :inline :offset-assert 16) -; (bucket-index uint16 :offset-assert 6) -; (origin matrix4h :inline :offset-assert 32) -; (wind-index uint16 :offset-assert 62) -; (flat-normal vector :inline :offset-assert 64) -; (flat-hwidth float :offset-assert 76) -; (color uint32 :offset-assert 8) -; ) -; :method-count-assert 18 -; :size-assert #x50 -; :flag-assert #x1200000050 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; ) -; ) +;; shrubbery-h +(deftype instance-shrubbery (instance) + ((flat-normal vector :inline :offset-assert 64) + (flat-hwidth float :offset 76) + (color uint32 :offset 8) + ) + :method-count-assert 18 + :size-assert #x50 + :flag-assert #x1200000050 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) -; ;; shrubbery-h -; (deftype generic-shrub-fragment (drawable) -; ((id int16 :offset-assert 4) -; (bsphere vector :inline :offset-assert 16) -; (textures uint32 :offset-assert 4) -; (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 18 -; :size-assert #x20 -; :flag-assert #x1200000020 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; ) -; ) +;; shrubbery-h +(deftype generic-shrub-fragment (drawable) + ((textures uint32 :offset 4) + (vtx-cnt uint32 :offset 8) + (cnt-qwc uint8 :offset 12) + (vtx-qwc uint8 :offset 13) + (col-qwc uint8 :offset 14) + (stq-qwc uint8 :offset 15) + (cnt uint32 :offset 16) + (vtx uint32 :offset 20) + (col uint32 :offset 24) + (stq uint32 :offset 28) + ) + :method-count-assert 18 + :size-assert #x20 + :flag-assert #x1200000020 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + ) + ) -; ;; shrubbery-h -; (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 -; ) +;; shrubbery-h +(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 + ) ; ;; shrubbery-h ; (deftype shrub-near-packet (structure) @@ -9035,57 +8905,57 @@ ; :flag-assert #x9000000e0 ; ) -; ;; tfrag-h -; (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 -; ) +;; tfrag-h +(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 + ) -; ;; tfrag-h -; (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 -; ) +;; tfrag-h +(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 + ) ; ;; tfrag-h ; (deftype tfrag-packet (structure) @@ -9096,36 +8966,36 @@ ; :flag-assert #x900000020 ; ) -; ;; tfrag-h -; (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) -; (max-dist vector :inline :offset-assert 96) -; (min-dist vector :inline :offset-assert 112) -; (color-ptr vector4w :inline :offset-assert 128) -; (tr-stat-tfrag tr-stat :offset-assert 144) -; (tr-stat-tfrag-near tr-stat :offset-assert 148) -; (vu1-enable-tfrag int32 :offset-assert 152) -; (vu1-enable-tfrag-near int32 :offset-assert 156) -; (cur-vis-bits uint32 :offset-assert 160) -; (end-vis-bits uint32 :offset-assert 164) -; (src-ptr uint32 :offset-assert 168) -; (last-call uint32 :offset-assert 172) -; (dma-buffer basic :offset-assert 176) -; (test-id uint32 :offset-assert 180) -; (wait-from-spr uint32 :offset-assert 184) -; (wait-to-spr uint32 :offset-assert 188) -; (near-wait-from-spr uint32 :offset-assert 192) -; (near-wait-to-spr uint32 :offset-assert 196) -; ) -; :method-count-assert 9 -; :size-assert #xc8 -; :flag-assert #x9000000c8 -; ) +;; tfrag-h +(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) + (max-dist vector :inline :offset-assert 96) + (min-dist vector :inline :offset-assert 112) + (color-ptr vector4w :inline :offset-assert 128) + (tr-stat-tfrag tr-stat :offset-assert 144) + (tr-stat-tfrag-near tr-stat :offset-assert 148) + (vu1-enable-tfrag int32 :offset-assert 152) + (vu1-enable-tfrag-near int32 :offset-assert 156) + (cur-vis-bits uint32 :offset-assert 160) + (end-vis-bits uint32 :offset-assert 164) + (src-ptr uint32 :offset-assert 168) + (last-call uint32 :offset-assert 172) + (dma-buffer basic :offset-assert 176) + (test-id uint32 :offset-assert 180) + (wait-from-spr uint32 :offset-assert 184) + (wait-to-spr uint32 :offset-assert 188) + (near-wait-from-spr uint32 :offset-assert 192) + (near-wait-to-spr uint32 :offset-assert 196) + ) + :method-count-assert 9 + :size-assert #xc8 + :flag-assert #x9000000c8 + ) ; ;; tfrag-h ; (deftype tfrag-dma (structure) @@ -9258,39 +9128,39 @@ ; :flag-assert #x9000000c0 ; ) -; ;; subdivide-h -; (deftype terrain-bsp (structure) -; ((lev-index int32 :offset-assert 0) -; (mood basic :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #x8 -; :flag-assert #x900000008 -; ) +;; subdivide-h +(deftype terrain-bsp (structure) + ((lev-index int32 :offset-assert 0) + (mood basic :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) -; ;; subdivide-h -; (deftype terrain-stats (structure) -; ((pris tr-stat :inline :offset-assert 0) -; (tie-generic tr-stat :inline :offset-assert 16) -; (tie tr-stat :inline :offset-assert 32) -; (tie-near tr-stat :inline :offset-assert 48) -; (shrub-near tr-stat :inline :offset-assert 64) -; (shrub tr-stat :inline :offset-assert 80) -; (tfrag-near tr-stat :inline :offset-assert 96) -; (tfrag tr-stat :inline :offset-assert 112) -; (billboard tr-stat :inline :offset-assert 128) -; (trans-tfrag tr-stat :inline :offset-assert 144) -; (trans-tfrag-near tr-stat :inline :offset-assert 160) -; (trans-pris tr-stat :inline :offset-assert 176) -; (trans-shrub tr-stat :inline :offset-assert 192) -; (ocean-mid tr-stat :inline :offset-assert 208) -; (ocean-near tr-stat :inline :offset-assert 224) -; (total tr-stat :inline :offset-assert 240) -; ) -; :method-count-assert 9 -; :size-assert #x100 -; :flag-assert #x900000100 -; ) +;; subdivide-h +(deftype terrain-stats (structure) + ((pris tr-stat :inline :offset-assert 0) + (tie-generic tr-stat :inline :offset-assert 16) + (tie tr-stat :inline :offset-assert 32) + (tie-near tr-stat :inline :offset-assert 48) + (shrub-near tr-stat :inline :offset-assert 64) + (shrub tr-stat :inline :offset-assert 80) + (tfrag-near tr-stat :inline :offset-assert 96) + (tfrag tr-stat :inline :offset-assert 112) + (billboard tr-stat :inline :offset-assert 128) + (trans-tfrag tr-stat :inline :offset-assert 144) + (trans-tfrag-near tr-stat :inline :offset-assert 160) + (trans-pris tr-stat :inline :offset-assert 176) + (trans-shrub tr-stat :inline :offset-assert 192) + (ocean-mid tr-stat :inline :offset-assert 208) + (ocean-near tr-stat :inline :offset-assert 224) + (total tr-stat :inline :offset-assert 240) + ) + :method-count-assert 9 + :size-assert #x100 + :flag-assert #x900000100 + ) ; ;; subdivide-h ; (deftype dma-area (structure) @@ -9451,38 +9321,38 @@ ; ;; entity-h ; (deftype entity-ambient-data-array (inline-array-class) ; ((length int32 :offset-assert 4) -; (allocated-length int32 :offset-assert 8) -; (data UNKNOWN :dynamic :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) - -; ;; entity-h -; (deftype entity-info (basic) -; ((ptype basic :offset-assert 4) -; (package basic :offset-assert 8) -; (art-group basic :offset-assert 12) -; (pool basic :offset-assert 16) -; (heap-size int32 :offset-assert 20) -; ) -; :method-count-assert 9 -; :size-assert #x18 -; :flag-assert #x900000018 -; ) - -; ;; entity-h -; (deftype actor-bank (basic) -; ((pause-dist float :offset-assert 4) -; (birth-dist float :offset-assert 8) -; (birth-max int32 :offset-assert 12) +; (allocated-length int32 :offset-assert 8) +; (data UNKNOWN :dynamic :offset-assert 16) ; ) ; :method-count-assert 9 ; :size-assert #x10 ; :flag-assert #x900000010 ; ) +;; entity-h +(deftype entity-info (basic) + ((ptype basic :offset-assert 4) + (package basic :offset-assert 8) + (art-group basic :offset-assert 12) + (pool basic :offset-assert 16) + (heap-size int32 :offset-assert 20) + ) + :method-count-assert 9 + :size-assert #x18 + :flag-assert #x900000018 + ) + +;; entity-h +(deftype actor-bank (basic) + ((pause-dist float :offset-assert 4) + (birth-dist float :offset-assert 8) + (birth-max int32 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + ; ;; sprite-h ; (deftype sprite-vec-data-2d (structure) ; ((x-y-z-sx vector :inline :offset-assert 0) @@ -9565,70 +9435,71 @@ ; :flag-assert #x900000030 ; ) -; ;; shadow-h -; (deftype fake-shadow (structure) -; ((px float :offset-assert 0) -; (py float :offset-assert 4) -; (pz float :offset-assert 8) -; (scale float :offset-assert 12) -; (qx float :offset-assert 16) -; (qy float :offset-assert 20) -; (qz float :offset-assert 24) -; (flags int32 :offset-assert 28) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 -; ) +;; shadow-h +(deftype fake-shadow (structure) + ((px float :offset-assert 0) + (py float :offset-assert 4) + (pz float :offset-assert 8) + (scale float :offset-assert 12) + (qx float :offset-assert 16) + (qy float :offset-assert 20) + (qz float :offset-assert 24) + (flags int32 :offset-assert 28) + ) + :pack-me + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) -; ;; shadow-h -; (deftype fake-shadow-buffer (basic) -; ((num-shadows int32 :offset-assert 4) -; (data UNKNOWN 32 :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #x408 -; :flag-assert #x900000408 -; ) +;; shadow-h +(deftype fake-shadow-buffer (basic) + ((num-shadows int32 :offset-assert 4) + (data fake-shadow 32 :inline :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #x408 + :flag-assert #x900000408 + ) -; ;; eye-h -; (deftype eye (structure) -; ((data UNKNOWN 2 :offset-assert 0) -; (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) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 -; ) +;; eye-h +(deftype eye (structure) + ((data uint128 2 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (lid float :offset 8) + (iris-scale float :offset 16) + (pupil-scale float :offset 20) + (lid-scale float :offset 24) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) -; ;; eye-h -; (deftype eye-control (structure) -; ((process uint64 :offset-assert 0) -; (random-time uint16 :offset-assert 8) -; (level uint16 :offset-assert 10) -; (blink float :offset-assert 12) -; (shaders uint32 :offset-assert 16) -; (left eye :inline :offset-assert 32) -; (right eye :inline :offset-assert 64) -; ) -; :method-count-assert 9 -; :size-assert #x60 -; :flag-assert #x900000060 -; ) +;; eye-h +(deftype eye-control (structure) + ((process uint64 :offset-assert 0) + (random-time uint16 :offset-assert 8) + (level uint16 :offset-assert 10) + (blink float :offset-assert 12) + (shaders uint32 :offset-assert 16) + (left eye :inline :offset-assert 32) + (right eye :inline :offset-assert 64) + ) + :method-count-assert 9 + :size-assert #x60 + :flag-assert #x900000060 + ) -; ;; eye-h -; (deftype eye-control-array (basic) -; ((data UNKNOWN 11 :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x430 -; :flag-assert #x900000430 -; ) +;; eye-h +(deftype eye-control-array (basic) + ((data eye-control 11 :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x430 + :flag-assert #x900000430 + ) ; ;; eye-h ; (deftype eye-work (structure) @@ -9642,54 +9513,54 @@ ; :flag-assert #x900000088 ; ) -; ;; sparticle-launcher-h -; (deftype sp-field-init-spec (structure) -; ((field uint16 :offset-assert 0) -; (flags uint16 :offset-assert 2) -; (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 basic :offset-assert 4) -; (tex uint32 :offset-assert 4) -; (pntr uint32 :offset-assert 4) -; (sym basic :offset-assert 4) -; (sound basic :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; sparticle-launcher-h +(deftype sp-field-init-spec (structure) + ((field uint16 :offset-assert 0) + (flags uint16 :offset-assert 2) + (initial-valuef float :offset-assert 4) + (random-rangef float :offset-assert 8) + (random-multf float :offset-assert 12) + (initial-value int32 :offset 4) + (random-range int32 :offset 8) + (random-mult int32 :offset 12) + (func basic :offset 4) + (tex uint32 :offset 4) + (pntr uint32 :offset 4) + (sym basic :offset 4) + (sound basic :offset 4) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) -; ;; sparticle-launcher-h -; (deftype sparticle-launcher (basic) -; ((birthaccum float :offset-assert 4) -; (soundaccum float :offset-assert 8) -; (init-specs uint32 :offset-assert 12) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; sparticle-launcher-h +(deftype sparticle-launcher (basic) + ((birthaccum float :offset-assert 4) + (soundaccum float :offset-assert 8) + (init-specs uint32 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) -; ;; sparticle-launcher-h -; (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) -; (period uint16 :offset-assert 14) -; (length uint16 :offset-assert 16) -; (offset uint16 :offset-assert 18) -; (hour-mask uint32 :offset-assert 20) -; (binding uint32 :offset-assert 24) -; ) -; :method-count-assert 9 -; :size-assert #x1c -; :flag-assert #x90000001c -; ) +;; sparticle-launcher-h +(deftype sparticle-group-item (structure) + ((launcher uint32 :offset-assert 0) + (fade-after float :offset-assert 4) ;; meters + (falloff-to float :offset-assert 8) ;; meters + (flags uint16 :offset-assert 12) + (period uint16 :offset-assert 14) + (length uint16 :offset-assert 16) + (offset uint16 :offset-assert 18) + (hour-mask uint32 :offset-assert 20) + (binding uint32 :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) ; ;; sparticle-launcher-h ; (deftype sparticle-launch-state (structure) @@ -9713,23 +9584,23 @@ ; :flag-assert #x900000020 ; ) -; ;; sparticle-launcher-h -; (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) -; (name basic :offset-assert 12) -; (launcher uint32 :offset-assert 16) -; (bounds sphere :inline :offset-assert 32) -; ) -; :method-count-assert 10 -; :size-assert #x30 -; :flag-assert #xa00000030 -; (:methods -; (dummy-9 () none 9) -; ) -; ) +;; sparticle-launcher-h +(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) + (name basic :offset-assert 12) + (launcher uint32 :offset-assert 16) + (bounds sphere :inline :offset-assert 32) + ) + :method-count-assert 10 + :size-assert #x30 + :flag-assert #xa00000030 + (:methods + (dummy-9 () none 9) + ) + ) ; ;; sparticle-launcher-h ; (deftype sparticle-launch-control (inline-array-class) @@ -9827,35 +9698,35 @@ ; :flag-assert #x900000034 ; ) -; ;; actor-link-h -; (deftype actor-link-info (basic) -; ((process basic :offset-assert 4) -; (next basic :offset-assert 8) -; (prev basic :offset-assert 12) -; ) -; :method-count-assert 26 -; :size-assert #x10 -; :flag-assert #x1a00000010 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; (dummy-24 () none 24) -; (dummy-25 () none 25) -; ) -; ) +;; actor-link-h +(deftype actor-link-info (basic) + ((process basic :offset-assert 4) + (next basic :offset-assert 8) + (prev basic :offset-assert 12) + ) + :method-count-assert 26 + :size-assert #x10 + :flag-assert #x1a00000010 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + ) + ) ; ;; camera-h ; (deftype camera-bank (basic) @@ -9875,424 +9746,404 @@ ; :flag-assert #x900000030 ; ) -; ;; camera-h -; (deftype cam-index (structure) -; ((flags uint32 :offset-assert 0) -; (vec UNKNOWN 2 :offset-assert 16) -; ) -; :method-count-assert 11 -; :size-assert #x30 -; :flag-assert #xb00000030 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) -; ) - -; ;; camera-h -; (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 -; ) - -; ;; camera-h -; (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 -; ) +;; camera-h +(deftype cam-index (structure) + ((flags uint32 :offset-assert 0) + (vec uint128 2 :offset-assert 16) + ) + :method-count-assert 11 + :size-assert #x30 + :flag-assert #xb00000030 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) -; ;; camera-h -; (deftype tracking-spline (structure) -; ((point UNKNOWN 32 :offset-assert 0) -; (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 -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; ) -; ) +;; camera-h +(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 + ) -; ;; camera-h -; (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 -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; ) -; ) +;; camera-h +(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 + ) -; ;; camera-h -; (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 -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) -; ) +;; camera-h +(deftype tracking-spline (structure) + ((point tracking-point 32 :inline :offset-assert 0) + (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 + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + ) + ) -; ;; camera-h -; (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) -; (use-point-of-interest basic :offset-assert 140) -; (point-of-interest vector :inline :offset-assert 144) -; (point-of-interest-blend cam-float-seeker :inline :offset-assert 160) -; (underwater-blend cam-float-seeker :inline :offset-assert 184) -; ) -; :method-count-assert 9 -; :size-assert #xd0 -; :flag-assert #x9000000d0 -; ) +;; camera-h +(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) + ) + :pack-me + :method-count-assert 13 + :size-assert #x18 + :flag-assert #xd00000018 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) -; ;; camera-h -; (deftype camera-combiner (process) -; ((~Ttrans vector :inline :offset-assert 112) -; (~Tinv-camera-rot matrix :inline :offset-assert 128) -; (~Tfov float :offset-assert 192) -; (~Tinterp-val float :offset-assert 196) -; (~Tinterp-step float :offset-assert 200) -; (~Tdist-from-src float :offset-assert 204) -; (~Tdist-from-dest float :offset-assert 208) -; (~Tflip-control-axis vector :inline :offset-assert 224) -; (~Tvelocity vector :inline :offset-assert 240) -; (~Ttracking-status uint64 :offset-assert 256) -; (~Ttracking-options int32 :offset-assert 264) -; (~Ttracking cam-rotation-tracker :inline :offset-assert 272) -; ) -; :method-count-assert 14 -; :size-assert #x1e0 -; :flag-assert #xe017001e0 -; ;; inherited inpspect of process -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; ) -; ) +;; camera-h +(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 + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) -; ;; camera-h -; (deftype camera-slave (process) -; ((~Ttrans vector :inline :offset-assert 112) -; (~Tfov float :offset-assert 128) -; (~Tfov0 float :offset-assert 132) -; (~Tfov1 float :offset-assert 136) -; (~Tfov-index cam-index :inline :offset-assert 144) -; (~Ttracking cam-rotation-tracker :inline :offset-assert 192) -; (~Tview-off-param float :offset-assert 400) -; (~Tview-off vector :inline :offset-assert 416) -; (~Tmin-z-override float :offset-assert 432) -; (~Tview-flat vector :inline :offset-assert 448) -; (~Tstring-vel-dir uint32 :offset-assert 464) -; (~Tstring-trans vector :inline :offset-assert 480) -; (~Tposition-spline tracking-spline :inline :offset-assert 496) -; (~Tpivot-pt vector :inline :offset-assert 2144) -; (~Tpivot-rad float :offset-assert 2160) -; (~Tcircular-follow vector :inline :offset-assert 2176) -; (~Tmax-angle-offset float :offset-assert 2192) -; (~Tmax-angle-curr float :offset-assert 2196) -; (~Toptions uint32 :offset-assert 2200) -; (~Tcam-entity basic :offset-assert 2204) -; (~Tvelocity vector :inline :offset-assert 2208) -; (~Tdesired-pos vector :inline :offset-assert 2224) -; (~Ttime-dist-too-far uint32 :offset-assert 2240) -; (~Tlos-state uint32 :offset-assert 2244) -; (~Tgood-point vector :inline :offset-assert 2256) -; (~Tlos-tgt-spline-pt int32 :offset-assert 2272) -; (~Tlos-tgt-spline-pt-incarnation int32 :offset-assert 2276) -; (~Tlos-last-pos vector :inline :offset-assert 2288) -; (~Tintro-curve curve :inline :offset-assert 2304) -; (~Tintro-offset vector :inline :offset-assert 2336) -; (~Tintro-t float :offset-assert 2352) -; (~Tintro-t-step float :offset-assert 2356) -; (~Toutro-exit-value float :offset-assert 2360) -; (~Tspline-exists basic :offset-assert 2364) -; (~Tspline-curve curve :inline :offset-assert 2368) -; (~Tspline-offset vector :inline :offset-assert 2400) -; (~Tindex cam-index :inline :offset-assert 2416) -; (~Tsaved-pt vector :inline :offset-assert 2464) -; (~Tspline-tt float :offset-assert 2480) -; (~Tspline-follow-dist float :offset-assert 2484) -; (~Tchange-event-from uint32 :offset-assert 2488) -; (~Tenter-has-run basic :offset-assert 2492) -; (~Tblend-from-type uint64 :offset-assert 2496) -; (~Tblend-to-type uint64 :offset-assert 2504) -; (~Thave-phony-joystick basic :offset-assert 2512) -; (~Tphony-joystick-x float :offset-assert 2516) -; (~Tphony-joystick-y float :offset-assert 2520) -; (~Tstring-min-val vector :inline :offset-assert 2528) -; (~Tstring-max-val vector :inline :offset-assert 2544) -; (~Tstring-val-locked basic :offset-assert 2560) -; ) -; :method-count-assert 14 -; :size-assert #xa04 -; :flag-assert #xe09a00a04 -; ;; inherited inpspect of process -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; ) -; ) +;; camera-h +(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) + (use-point-of-interest basic :offset-assert 140) + (point-of-interest vector :inline :offset-assert 144) + (point-of-interest-blend cam-float-seeker :inline :offset-assert 160) + (underwater-blend cam-float-seeker :inline :offset-assert 184) + ) + :method-count-assert 9 + :size-assert #xd0 + :flag-assert #x9000000d0 + ) + +;; camera-h +(deftype camera-combiner (process) + ((~Ttrans vector :inline :offset-assert 112) + (~Tinv-camera-rot matrix :inline :offset-assert 128) + (~Tfov float :offset-assert 192) + (~Tinterp-val float :offset-assert 196) + (~Tinterp-step float :offset-assert 200) + (~Tdist-from-src float :offset-assert 204) + (~Tdist-from-dest float :offset-assert 208) + (~Tflip-control-axis vector :inline :offset-assert 224) + (~Tvelocity vector :inline :offset-assert 240) + (~Ttracking-status uint64 :offset-assert 256) + (~Ttracking-options int32 :offset-assert 264) + (~Ttracking cam-rotation-tracker :inline :offset-assert 272) + ) + :heap-base #x170 + :method-count-assert 14 + :size-assert #x1e0 + :flag-assert #xe017001e0 + ;; inherited inpspect of process + ) -; ;; camera-h -; (deftype camera-master (process) -; ((~Tmaster-options uint32 :offset-assert 112) -; (~Tnum-slaves int32 :offset-assert 116) -; (~Tslave UNKNOWN 2 :offset-assert 120) -; (~Tslave-options uint32 :offset-assert 128) -; (~Tview-off-param-save float :offset-assert 132) -; (~Tchanger uint32 :offset-assert 136) -; (~Tcam-entity basic :offset-assert 140) -; (~TstringMinLength float :offset-assert 144) -; (~TstringMaxLength float :offset-assert 148) -; (~TstringMinHeight float :offset-assert 152) -; (~TstringMaxHeight float :offset-assert 156) -; (~Tstring-min cam-vector-seeker :inline :offset-assert 160) -; (~Tstring-max cam-vector-seeker :inline :offset-assert 224) -; (~Tstring-push-z float :offset-assert 284) -; (~TstringCliffHeight float :offset-assert 288) -; (~Tno-intro uint32 :offset-assert 292) -; (~Tforce-blend uint32 :offset-assert 296) -; (~Tforce-blend-time uint32 :offset-assert 300) -; (~Tlocal-down vector :inline :offset-assert 304) -; (~Tdrawable-target uint64 :offset-assert 320) -; (~Twhich-bone int32 :offset-assert 328) -; (~Tpov-handle uint64 :offset-assert 336) -; (~Tpov-bone int32 :offset-assert 344) -; (~Tbeing-attacked basic :offset-assert 348) -; (~Tattack-start uint64 :offset-assert 352) -; (~Ton-ground basic :offset-assert 360) -; (~Tunder-water int32 :offset-assert 364) -; (~Ton-pole basic :offset-assert 368) -; (~Ttgt-rot-mat matrix :inline :offset-assert 384) -; (~Ttgt-face-mat matrix :inline :offset-assert 448) -; (~Ttpos-old vector :inline :offset-assert 512) -; (~Ttpos-curr vector :inline :offset-assert 528) -; (~Ttarget-height float :offset-assert 544) -; (~Ttpos-old-adj vector :inline :offset-assert 560) -; (~Ttpos-curr-adj vector :inline :offset-assert 576) -; (~Ttpos-tgt vector :inline :offset-assert 592) -; (~Tupspeed float :offset-assert 608) -; (~Tpitch-off vector :inline :offset-assert 624) -; (~Tfoot-offset float :offset-assert 640) -; (~Thead-offset float :offset-assert 644) -; (~Ttarget-spline tracking-spline :inline :offset-assert 656) -; (~Tease-from vector :inline :offset-assert 2304) -; (~Tease-t float :offset-assert 2320) -; (~Tease-step float :offset-assert 2324) -; (~Tease-to vector :inline :offset-assert 2336) -; (~Toutro-curve curve :inline :offset-assert 2352) -; (~Toutro-t float :offset-assert 2372) -; (~Toutro-t-step float :offset-assert 2376) -; (~Toutro-exit-value float :offset-assert 2380) -; (~Twater-drip-time uint64 :offset-assert 2384) -; (~Twater-drip basic :offset-assert 2392) -; (~Twater-drip-mult float :offset-assert 2396) -; (~Twater-drip-speed float :offset-assert 2400) -; ) -; :method-count-assert 14 -; :size-assert #x964 -; :flag-assert #xe09000964 -; ;; inherited inpspect of process -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; ) -; ) +;; camera-h +(deftype camera-slave (process) + ((~Ttrans vector :inline :offset-assert 112) + (~Tfov float :offset-assert 128) + (~Tfov0 float :offset-assert 132) + (~Tfov1 float :offset-assert 136) + (~Tfov-index cam-index :inline :offset-assert 144) + (~Ttracking cam-rotation-tracker :inline :offset-assert 192) + (~Tview-off-param float :offset-assert 400) + (~Tview-off vector :inline :offset-assert 416) + (~Tmin-z-override float :offset-assert 432) + (~Tview-flat vector :inline :offset-assert 448) + (~Tstring-vel-dir uint32 :offset-assert 464) + (~Tstring-trans vector :inline :offset-assert 480) + (~Tposition-spline tracking-spline :inline :offset-assert 496) + (~Tpivot-pt vector :inline :offset-assert 2144) + (~Tpivot-rad float :offset-assert 2160) + (~Tcircular-follow vector :inline :offset-assert 2176) + (~Tmax-angle-offset float :offset-assert 2192) + (~Tmax-angle-curr float :offset-assert 2196) + (~Toptions uint32 :offset-assert 2200) + (~Tcam-entity basic :offset-assert 2204) + (~Tvelocity vector :inline :offset-assert 2208) + (~Tdesired-pos vector :inline :offset-assert 2224) + (~Ttime-dist-too-far uint32 :offset-assert 2240) + (~Tlos-state uint32 :offset-assert 2244) + (~Tgood-point vector :inline :offset-assert 2256) + (~Tlos-tgt-spline-pt int32 :offset-assert 2272) + (~Tlos-tgt-spline-pt-incarnation int32 :offset-assert 2276) + (~Tlos-last-pos vector :inline :offset-assert 2288) + (~Tintro-curve curve :inline :offset-assert 2304) + (~Tintro-offset vector :inline :offset-assert 2336) + (~Tintro-t float :offset-assert 2352) + (~Tintro-t-step float :offset-assert 2356) + (~Toutro-exit-value float :offset-assert 2360) + (~Tspline-exists basic :offset-assert 2364) + (~Tspline-curve curve :inline :offset-assert 2368) + (~Tspline-offset vector :inline :offset-assert 2400) + (~Tindex cam-index :inline :offset-assert 2416) + (~Tsaved-pt vector :inline :offset-assert 2464) + (~Tspline-tt float :offset-assert 2480) + (~Tspline-follow-dist float :offset-assert 2484) + (~Tchange-event-from uint32 :offset-assert 2488) + (~Tenter-has-run basic :offset-assert 2492) + (~Tblend-from-type uint64 :offset-assert 2496) + (~Tblend-to-type uint64 :offset-assert 2504) + (~Thave-phony-joystick basic :offset-assert 2512) + (~Tphony-joystick-x float :offset-assert 2516) + (~Tphony-joystick-y float :offset-assert 2520) + (~Tstring-min-val vector :inline :offset-assert 2528) + (~Tstring-max-val vector :inline :offset-assert 2544) + (~Tstring-val-locked basic :offset-assert 2560) + ) + :heap-base #x9a0 + :method-count-assert 14 + :size-assert #xa04 + :flag-assert #xe09a00a04 + ;; inherited inpspect of process + ) -; ;; assert-h -; (deftype __assert-info-private-struct (structure) -; ((filename basic :offset-assert 0) -; (line-num uint16 :offset-assert 4) -; (column-num uint16 :offset-assert 6) -; ) -; :method-count-assert 11 -; :size-assert #x8 -; :flag-assert #xb00000008 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) -; ) +;; camera-h +(deftype camera-master (process) + ((~Tmaster-options uint32 :offset-assert 112) + (~Tnum-slaves int32 :offset-assert 116) + (~Tslave basic 2 :offset-assert 120) + (~Tslave-options uint32 :offset-assert 128) + (~Tview-off-param-save float :offset-assert 132) + (~Tchanger uint32 :offset-assert 136) + (~Tcam-entity basic :offset-assert 140) + (~TstringMinLength float :offset-assert 144) + (~TstringMaxLength float :offset-assert 148) + (~TstringMinHeight float :offset-assert 152) + (~TstringMaxHeight float :offset-assert 156) + (~Tstring-min cam-vector-seeker :inline :offset-assert 160) + (~Tstring-max cam-vector-seeker :inline :offset-assert 224) + (~Tstring-push-z float :offset-assert 284) + (~TstringCliffHeight float :offset-assert 288) + (~Tno-intro uint32 :offset-assert 292) + (~Tforce-blend uint32 :offset-assert 296) + (~Tforce-blend-time uint32 :offset-assert 300) + (~Tlocal-down vector :inline :offset-assert 304) + (~Tdrawable-target uint64 :offset-assert 320) + (~Twhich-bone int32 :offset-assert 328) + (~Tpov-handle uint64 :offset-assert 336) + (~Tpov-bone int32 :offset-assert 344) + (~Tbeing-attacked basic :offset-assert 348) + (~Tattack-start uint64 :offset-assert 352) + (~Ton-ground basic :offset-assert 360) + (~Tunder-water int32 :offset-assert 364) + (~Ton-pole basic :offset-assert 368) + (~Ttgt-rot-mat matrix :inline :offset-assert 384) + (~Ttgt-face-mat matrix :inline :offset-assert 448) + (~Ttpos-old vector :inline :offset-assert 512) + (~Ttpos-curr vector :inline :offset-assert 528) + (~Ttarget-height float :offset-assert 544) + (~Ttpos-old-adj vector :inline :offset-assert 560) + (~Ttpos-curr-adj vector :inline :offset-assert 576) + (~Ttpos-tgt vector :inline :offset-assert 592) + (~Tupspeed float :offset-assert 608) + (~Tpitch-off vector :inline :offset-assert 624) + (~Tfoot-offset float :offset-assert 640) + (~Thead-offset float :offset-assert 644) + (~Ttarget-spline tracking-spline :inline :offset-assert 656) + (~Tease-from vector :inline :offset-assert 2304) + (~Tease-t float :offset-assert 2320) + (~Tease-step float :offset-assert 2324) + (~Tease-to vector :inline :offset-assert 2336) + (~Toutro-curve curve :inline :offset-assert 2352) + (~Toutro-t float :offset-assert 2372) + (~Toutro-t-step float :offset-assert 2376) + (~Toutro-exit-value float :offset-assert 2380) + (~Twater-drip-time uint64 :offset-assert 2384) + (~Twater-drip basic :offset-assert 2392) + (~Twater-drip-mult float :offset-assert 2396) + (~Twater-drip-speed float :offset-assert 2400) + ) + :heap-base #x900 + :method-count-assert 14 + :size-assert #x964 + :flag-assert #xe09000964 + ;; inherited inpspect of process + ) -; ;; hud-h -; (deftype hud-icon (basic) -; ((icon uint32 :offset-assert 4) -; (icon-y int32 :offset-assert 8) -; (icon-x int32 :offset-assert 12) -; (icon-z int32 :offset-assert 16) -; (scale-x float :offset-assert 20) -; (scale-y float :offset-assert 24) -; ) -; :method-count-assert 9 -; :size-assert #x1c -; :flag-assert #x90000001c -; ) +;; assert-h +(deftype __assert-info-private-struct (structure) + ((filename basic :offset-assert 0) + (line-num uint16 :offset-assert 4) + (column-num uint16 :offset-assert 6) + ) + :method-count-assert 11 + :size-assert #x8 + :flag-assert #xb00000008 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) -; ;; hud-h -; (deftype hud-particle (basic) -; ((part basic :offset-assert 4) -; (init-pos vector :inline :offset-assert 16) -; (pos vector :inline :offset-assert 32) -; (prev-pos vector :inline :offset-assert 48) -; ) -; :method-count-assert 9 -; :size-assert #x40 -; :flag-assert #x900000040 -; ) +;; hud-h +(deftype hud-icon (basic) + ((icon uint32 :offset-assert 4) + (icon-y int32 :offset-assert 8) + (icon-x int32 :offset-assert 12) + (icon-z int32 :offset-assert 16) + (scale-x float :offset-assert 20) + (scale-y float :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) -; ;; hud-h -; (deftype hud (process) -; ((~Tvalue int32 :offset-assert 112) -; (~Tvalue2 int32 :offset-assert 116) -; (~Ttarget-value int32 :offset-assert 120) -; (~Tlast-increment-time uint64 :offset-assert 128) -; (~Tlast-target-equal-time uint64 :offset-assert 136) -; (~Toffset int32 :offset-assert 144) -; (~Ty-offset int32 :offset-assert 148) -; (~Tnext-y-offset int32 :offset-assert 152) -; (~Tx-sgn int32 :offset-assert 156) -; (~Ty-sgn int32 :offset-assert 160) -; (~Ttext-x int32 :offset-assert 164) -; (~Ttext-y int32 :offset-assert 168) -; (~Tfriend int32 :offset-assert 172) -; (~Tfirst-init basic :offset-assert 176) -; (~Tincrement-on-event basic :offset-assert 180) -; (~Tskip-particle int32 :offset-assert 184) -; (~Tdisable basic :offset-assert 188) -; (~Tforce-on-screen basic :offset-assert 192) -; (~Tdeactivate-when-hidden basic :offset-assert 196) -; (~Ttrigger-time uint64 :offset-assert 200) -; (~Tlast-hide-time uint64 :offset-assert 208) -; (~Tnb-of-icons int32 :offset-assert 216) -; (~Ticons UNKNOWN 6 :offset-assert 220) -; (~Tmax-nb-of-particles int32 :offset-assert 244) -; (~Tnb-of-particles int32 :offset-assert 248) -; (~Tparticles UNKNOWN 7 :offset-assert 252) -; ) -; :method-count-assert 27 -; :size-assert #x118 -; :flag-assert #x1b00b00118 -; ;; inherited inpspect of process -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; (dummy-24 () none 24) -; (dummy-25 () none 25) -; (dummy-26 () none 26) -; ) -; ) +;; hud-h +(deftype hud-particle (basic) + ((part basic :offset-assert 4) + (init-pos vector :inline :offset-assert 16) + (pos vector :inline :offset-assert 32) + (prev-pos vector :inline :offset-assert 48) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) -; ;; hud-h -; (deftype hud-parts (structure) -; ((data UNKNOWN 9 :offset-assert 0) -; (pickups uint32 :offset-assert 0) -; (money uint32 :offset-assert 4) -; (fuel-cell uint32 :offset-assert 8) -; (health uint32 :offset-assert 12) -; (buzzers uint32 :offset-assert 16) -; (power uint32 :offset-assert 20) -; (bike-speed uint32 :offset-assert 24) -; (bike-heat uint32 :offset-assert 28) -; (money-all uint32 :offset-assert 32) -; ) -; :method-count-assert 9 -; :size-assert #x24 -; :flag-assert #x900000024 -; ) +;; hud-h +(deftype hud (process) + ((~Tvalue int32 :offset-assert 112) + (~Tvalue2 int32 :offset-assert 116) + (~Ttarget-value int32 :offset-assert 120) + (~Tlast-increment-time uint64 :offset-assert 128) + (~Tlast-target-equal-time uint64 :offset-assert 136) + (~Toffset int32 :offset-assert 144) + (~Ty-offset int32 :offset-assert 148) + (~Tnext-y-offset int32 :offset-assert 152) + (~Tx-sgn int32 :offset-assert 156) + (~Ty-sgn int32 :offset-assert 160) + (~Ttext-x int32 :offset-assert 164) + (~Ttext-y int32 :offset-assert 168) + (~Tfriend int32 :offset-assert 172) + (~Tfirst-init basic :offset-assert 176) + (~Tincrement-on-event basic :offset-assert 180) + (~Tskip-particle int32 :offset-assert 184) + (~Tdisable basic :offset-assert 188) + (~Tforce-on-screen basic :offset-assert 192) + (~Tdeactivate-when-hidden basic :offset-assert 196) + (~Ttrigger-time uint64 :offset-assert 200) + (~Tlast-hide-time uint64 :offset-assert 208) + (~Tnb-of-icons int32 :offset-assert 216) + (~Ticons hud-icon 6 :offset-assert 220) + (~Tmax-nb-of-particles int32 :offset-assert 244) + (~Tnb-of-particles int32 :offset-assert 248) + (~Tparticles hud-particle 7 :offset-assert 252) + ) + :heap-base #xb0 + :method-count-assert 27 + :size-assert #x118 + :flag-assert #x1b00b00118 + ;; inherited inpspect of process + (:methods + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + ) + ) -; ;; progress-h -; (deftype count-info (structure) -; ((money-count int32 :offset-assert 0) -; (buzzer-count int32 :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #x8 -; :flag-assert #x900000008 -; ) +;; hud-h +(deftype hud-parts (structure) + ( + ;(data UNKNOWN 9 :offset-assert 0) + (pickups uint32 :offset-assert 0) + (money uint32 :offset-assert 4) + (fuel-cell uint32 :offset-assert 8) + (health uint32 :offset-assert 12) + (buzzers uint32 :offset-assert 16) + (power uint32 :offset-assert 20) + (bike-speed uint32 :offset-assert 24) + (bike-heat uint32 :offset-assert 28) + (money-all uint32 :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x24 + :flag-assert #x900000024 + ) + +;; progress-h +(deftype count-info (structure) + ((money-count int32 :offset-assert 0) + (buzzer-count int32 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) ; ;; progress-h ; (deftype game-count-info (basic) @@ -10328,20 +10179,20 @@ ; :flag-assert #x900000034 ; ) -; ;; progress-h -; (deftype game-option (basic) -; ((option-type uint64 :offset-assert 8) -; (name uint32 :offset-assert 16) -; (scale basic :offset-assert 20) -; (param1 float :offset-assert 24) -; (param2 float :offset-assert 28) -; (param3 int32 :offset-assert 32) -; (value-to-modify uint32 :offset-assert 36) -; ) -; :method-count-assert 9 -; :size-assert #x28 -; :flag-assert #x900000028 -; ) +;; progress-h +(deftype game-option (basic) + ((option-type uint64 :offset-assert 8) + (name uint32 :offset-assert 16) + (scale basic :offset-assert 20) + (param1 float :offset-assert 24) + (param2 float :offset-assert 28) + (param3 int32 :offset-assert 32) + (value-to-modify uint32 :offset-assert 36) + ) + :method-count-assert 9 + :size-assert #x28 + :flag-assert #x900000028 + ) ; ;; progress-h ; (deftype progress (process) @@ -10548,59 +10399,53 @@ ; ) ; ) -; ;; navigate-h -; (deftype nav-poly (structure) -; ((id uint8 :offset-assert 0) -; (vertex UNKNOWN 3 :offset-assert 1) -; (adj-poly UNKNOWN 3 :offset-assert 4) -; (pat uint8 :offset-assert 7) -; ) -; :method-count-assert 9 -; :size-assert #x8 -; :flag-assert #x900000008 -; ) +;; navigate-h +(deftype nav-poly (structure) + ((id uint8 :offset-assert 0) + (vertex uint8 3 :offset-assert 1) + (adj-poly uint8 3 :offset-assert 4) + (pat uint8 :offset-assert 7) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) -; ;; navigate-h -; (deftype nav-vertex (vector) -; ((data UNKNOWN 4 :offset-assert 0) -; (x float :offset-assert 0) -; (y float :offset-assert 4) -; (z float :offset-assert 8) -; (w float :offset-assert 12) -; (quad uint128 :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; navigate-h +(deftype nav-vertex (vector) + () + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) -; ;; navigate-h -; (deftype nav-sphere (structure) -; ((trans sphere :inline :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; navigate-h +(deftype nav-sphere (structure) + ((trans sphere :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) -; ;; navigate-h -; (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) -; (terminated basic :offset-assert 64) -; (reached-dest basic :offset-assert 68) -; (hit-boundary basic :offset-assert 72) -; (hit-gap basic :offset-assert 76) -; ) -; :method-count-assert 9 -; :size-assert #x50 -; :flag-assert #x900000050 -; ) +;; navigate-h +(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 float :offset-assert 56) ;; meters + (last-edge int8 :offset-assert 60) + (terminated basic :offset-assert 64) + (reached-dest basic :offset-assert 68) + (hit-boundary basic :offset-assert 72) + (hit-gap basic :offset-assert 76) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) ; ;; navigate-h ; (deftype nav-route-portal (structure) @@ -10613,25 +10458,25 @@ ; :flag-assert #x90000000d ; ) -; ;; navigate-h -; (deftype clip-travel-vector-to-mesh-return-info (structure) -; ((found-boundary basic :offset-assert 0) -; (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 int32 :offset-assert 88) -; (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 -; ) +;; navigate-h +(deftype clip-travel-vector-to-mesh-return-info (structure) + ((found-boundary basic :offset-assert 0) + (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 int32 :offset-assert 88) + (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 + ) ; ;; navigate-h ; (deftype nav-node (structure) @@ -10655,26 +10500,26 @@ ; (scale vector :inline :offset-assert 32) ; ) ; :method-count-assert 9 -; :size-assert #x30 -; :flag-assert #x900000030 -; ) - -; ;; navigate-h -; (deftype nav-lookup-elem (structure) -; ((vec vector :inline :offset-assert 0) -; (y-thresh float :offset-assert 12) -; (time uint32 :offset-assert 16) -; (node-offset uint32 :offset-assert 20) -; (lookup-type uint8 :offset-assert 24) -; (poly-ind uint8 :offset-assert 25) -; (dummy0 uint16 :offset-assert 26) -; (dummy uint32 :offset-assert 28) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 +; :size-assert #x30 +; :flag-assert #x900000030 ; ) +;; navigate-h +(deftype nav-lookup-elem (structure) + ((vec vector :inline :offset-assert 0) + (y-thresh float :offset 12) + (time uint32 :offset-assert 16) + (node-offset uint32 :offset-assert 20) + (lookup-type uint8 :offset-assert 24) + (poly-ind uint8 :offset-assert 25) + (dummy0 uint16 :offset-assert 26) + (dummy uint32 :offset-assert 28) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + ; ;; navigate-h ; (deftype nav-mesh (basic) ; ((user-list basic :offset-assert 4) @@ -10721,26 +10566,26 @@ ; ) ; ) -; ;; navigate-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 -; ) +;; navigate-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 + ) -; ;; navigate-h -; (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 -; ) +;; navigate-h +(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 + ) ; ;; navigate-h ; (deftype nav-control (basic) @@ -10805,20 +10650,20 @@ ; ) ; ) -; ;; load-dgo -; (deftype load-dgo-msg (structure) -; ((rsvd uint16 :offset-assert 0) -; (result uint16 :offset-assert 2) -; (b1 uint32 :offset-assert 4) -; (b2 uint32 :offset-assert 8) -; (bt uint32 :offset-assert 12) -; (name uint128 :offset-assert 16) -; (address uint32 :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 -; ) +;; load-dgo +(deftype load-dgo-msg (structure) + ((rsvd uint16 :offset-assert 0) + (result uint16 :offset-assert 2) + (b1 uint32 :offset-assert 4) + (b2 uint32 :offset-assert 8) + (bt uint32 :offset-assert 12) + (name uint128 :offset-assert 16) + (address uint32 :offset 4) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) ; ;; load-dgo ; (deftype load-chunk-msg (structure) @@ -10857,30 +10702,30 @@ ; :flag-assert #x900000020 ; ) -; ;; ramdisk -; (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 -; ) +;; ramdisk +(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 + ) -; ;; ramdisk -; (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 -; ) +;; ramdisk +(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 + ) ; ;; gsound ; (deftype sound-iop-info (basic) @@ -10924,7 +10769,7 @@ ; :flag-assert #x900000508 ; ) -; ;; joint +;; joint ; (deftype joint-anim-matrix (joint-anim) ; () ; :method-count-assert 9 @@ -11104,44 +10949,44 @@ ; :flag-assert #x9000012d0 ; ) -; ;; debug -; (deftype debug-line (structure) -; ((flags int32 :offset-assert 0) -; (bucket int32 :offset-assert 4) -; (v1 vector :inline :offset-assert 16) -; (v2 vector :inline :offset-assert 32) -; (color uint32 :offset-assert 48) -; (mode basic :offset-assert 52) -; (color2 uint32 :offset-assert 56) -; ) -; :method-count-assert 9 -; :size-assert #x3c -; :flag-assert #x90000003c -; ) +;; debug +(deftype debug-line (structure) + ((flags int32 :offset-assert 0) + (bucket int32 :offset-assert 4) + (v1 vector :inline :offset-assert 16) + (v2 vector :inline :offset-assert 32) + (color uint32 :offset-assert 48) + (mode basic :offset-assert 52) + (color2 uint32 :offset-assert 56) + ) + :method-count-assert 9 + :size-assert #x3c + :flag-assert #x90000003c + ) -; ;; debug -; (deftype debug-text-3d (structure) -; ((flags int32 :offset-assert 0) -; (bucket int32 :offset-assert 4) -; (pos vector :inline :offset-assert 16) -; (color uint64 :offset-assert 32) -; (offset vector2h :inline :offset-assert 40) -; (str basic :offset-assert 44) -; ) -; :method-count-assert 9 -; :size-assert #x30 -; :flag-assert #x900000030 -; ) +;; debug +(deftype debug-text-3d (structure) + ((flags int32 :offset-assert 0) + (bucket int32 :offset-assert 4) + (pos vector :inline :offset-assert 16) + (color uint64 :offset-assert 32) + (offset vector2h :inline :offset-assert 40) + (str basic :offset-assert 44) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) -; ;; debug -; (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 +(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 ; (deftype debug-vertex-stats (basic) @@ -11152,18 +10997,18 @@ ; ;; too many basic blocks ; ) -; ;; 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 -; ) +;; 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 + ) ; ;; merc-blend-shape ; (deftype blerc-block (structure) @@ -11184,20 +11029,20 @@ ; :flag-assert #x900000280 ; ) -; ;; merc-blend-shape -; (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 -; ) +;; merc-blend-shape +(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 + ) ; ;; merc-blend-shape ; (deftype blerc-context (structure) @@ -11295,18 +11140,18 @@ ; :flag-assert #x900000084 ; ) -; ;; bones -; (deftype merc-effect-bucket-info (structure) -; ((color-fade uint32 :offset-assert 0) -; (use-mercneric uint8 :offset-assert 4) -; (ignore-alpha uint8 :offset-assert 5) -; (pad0 uint8 :offset-assert 6) -; (pad1 uint8 :offset-assert 7) -; ) -; :method-count-assert 9 -; :size-assert #x8 -; :flag-assert #x900000008 -; ) +;; bones +(deftype merc-effect-bucket-info (structure) + ((color-fade uint32 :offset-assert 0) + (use-mercneric uint8 :offset-assert 4) + (ignore-alpha uint8 :offset-assert 5) + (pad0 uint8 :offset-assert 6) + (pad1 uint8 :offset-assert 7) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) ; ;; bones ; (deftype merc-bucket-info (structure) @@ -11321,16 +11166,16 @@ ; :flag-assert #x9000000fc ; ) -; ;; 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 -; ) +;; 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 + ) ; ;; generic-tie ; (deftype gsf-vertex (structure) @@ -11341,45 +11186,45 @@ ; ;; bad type dec string: [~8x] gsf-vertex~% ; ) -; ;; 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) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; 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) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) -; ;; shadow-cpu -; (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) -; (center vector :inline :offset-assert 64) -; (plane vector :inline :offset-assert 80) -; (top-plane vector :inline :offset-assert 96) -; (near-plane vector :inline :offset-assert 112) -; (light-dir vector :inline :offset-assert 128) -; (vtx-min vector :inline :offset-assert 144) -; (data UNKNOWN :dynamic :offset-assert 160) -; ) -; :method-count-assert 9 -; :size-assert #xa0 -; :flag-assert #x9000000a0 -; ) +;; shadow-cpu +(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) + (center vector :inline :offset-assert 64) + (plane vector :inline :offset-assert 80) + (top-plane vector :inline :offset-assert 96) + (near-plane vector :inline :offset-assert 112) + (light-dir vector :inline :offset-assert 128) + (vtx-min vector :inline :offset-assert 144) + (data uint8 :dynamic :offset-assert 160) + ) + :method-count-assert 9 + :size-assert #xa0 + :flag-assert #x9000000a0 + ) ; ;; shadow-vu1 ; (deftype shadow-vu1-constants (structure) @@ -11414,15 +11259,15 @@ ; :flag-assert #x900000050 ; ) -; ;; 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 -; ) +;; 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 + ) ; ;; draw-node ; (deftype drawable-inline-array-node (drawable-inline-array) @@ -11565,15 +11410,15 @@ ; :flag-assert #x9000000b0 ; ) -; ;; tie-methods -; (deftype tie-instance-debug (structure) -; ((max-instance uint32 :offset-assert 0) -; (min-instance uint32 :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #x8 -; :flag-assert #x900000008 -; ) +;; tie-methods +(deftype tie-instance-debug (structure) + ((max-instance uint32 :offset-assert 0) + (min-instance uint32 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) ; ;; sparticle-launcher ; (deftype sparticle-birthinfo (structure) @@ -11601,192 +11446,182 @@ ; ;; too many basic blocks ; ) -; ;; sparticle-launcher -; (deftype sp-queued-launch-particles (structure) -; ((sp-system basic :offset-assert 0) -; (sp-launcher basic :offset-assert 4) -; (pos vector :inline :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x20 -; :flag-assert #x900000020 -; ) - -; ;; sparticle-launcher -; (deftype sp-launch-queue (basic) -; ((in-use int32 :offset-assert 4) -; (queue UNKNOWN 32 :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x410 -; :flag-assert #x900000410 -; ) - -; ;; sparticle-launcher -; (deftype particle-adgif-cache (basic) -; ((used int32 :offset-assert 4) -; (last uint16 :offset-assert 8) -; (lastgif adgif-shader :offset-assert 12) -; (tidhash UNKNOWN 80 :offset-assert 16) -; (spadgif UNKNOWN 80 :offset-assert 176) -; ) -; :method-count-assert 9 -; :size-assert #x19b0 -; :flag-assert #x9000019b0 -; ) - -; ;; loader -; (deftype load-dir (basic) -; () -; :method-count-assert 11 -; :size-assert #x10 -; :flag-assert #xb00000010 -; ;; too many basic blocks -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; ) -; ) - -; ;; task-control-h -; (deftype task-cstage (structure) -; ((game-task uint8 :offset-assert 0) -; (status uint64 :offset-assert 8) -; (flags uint8 :offset-assert 16) -; (condition basic :offset-assert 20) -; ) -; :method-count-assert 16 -; :size-assert #x18 -; :flag-assert #x1000000018 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; ) -; ) - -; ;; task-control-h -; (deftype task-control (basic) -; ((current-stage int16 :offset-assert 4) -; (stage basic :offset-assert 8) -; ) -; :method-count-assert 19 -; :size-assert #xc -; :flag-assert #x130000000c -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; ) +;; sparticle-launcher +(deftype sp-queued-launch-particles (structure) + ((sp-system basic :offset-assert 0) + (sp-launcher basic :offset-assert 4) + (pos vector :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +; ;; sparticle-launcher +; (deftype sp-launch-queue (basic) +; ((in-use int32 :offset-assert 4) +; (queue UNKNOWN 32 :offset-assert 16) +; ) +; :method-count-assert 9 +; :size-assert #x410 +; :flag-assert #x900000410 ; ) -; ;; task-control-h -; (deftype ambient-control (structure) -; ((last-ambient-time uint64 :offset-assert 0) -; (last-ambient basic :offset-assert 8) -; (last-ambient-id uint32 :offset-assert 12) +; ;; sparticle-launcher +; (deftype particle-adgif-cache (basic) +; ((used int32 :offset-assert 4) +; (last uint16 :offset-assert 8) +; (lastgif adgif-shader :offset-assert 12) +; (tidhash UNKNOWN 80 :offset-assert 16) +; (spadgif UNKNOWN 80 :offset-assert 176) ; ) -; :method-count-assert 12 +; :method-count-assert 9 +; :size-assert #x19b0 +; :flag-assert #x9000019b0 +; ) + +; ;; loader +; (deftype load-dir (basic) +; () +; :method-count-assert 11 ; :size-assert #x10 -; :flag-assert #xc00000010 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; ) -; ) - -; ;; task-control-h -; (deftype process-taskable (process-drawable) -; ((~Ttasks basic :offset-assert 176) -; (~Tquery gui-query :inline :offset-assert 180) -; (~Told-target-pos transformq :inline :offset-assert 208) -; (~Tcell-for-task uint8 :offset-assert 256) -; (~Tcell-x uint64 :offset-assert 264) -; (~Tcam-joint-index int32 :offset-assert 272) -; (~Tskippable basic :offset-assert 276) -; (~Tblend-on-exit basic :offset-assert 280) -; (~Tcamera uint64 :offset-assert 288) -; (~Twill-talk basic :offset-assert 296) -; (~Ttalk-message uint32 :offset-assert 300) -; (~Tlast-talk uint64 :offset-assert 304) -; (~Tbounce-away basic :offset-assert 312) -; (~Tambient ambient-control :inline :offset-assert 320) -; (~Tcenter-joint-index int32 :offset-assert 336) -; (~Tdraw-bounds-y-offset float :offset-assert 340) -; (~Tneck-joint-index int32 :offset-assert 344) -; (~Tfuel-cell-anim basic :offset-assert 348) -; (~Tsound-flava uint8 :offset-assert 352) -; (~Thave-flava basic :offset-assert 356) -; (~Tmusic basic :offset-assert 360) -; (~Thave-music basic :offset-assert 364) -; (~Tbeen-kicked basic :offset-assert 368) -; (~Tcur-trans-hook basic :offset-assert 372) -; (~Tshadow-backup basic :offset-assert 376) -; ) -; :method-count-assert 53 -; :size-assert #x17c -; :flag-assert #x350110017c -; ;; inherited inpspect of process-drawable +; :flag-assert #xb00000010 +; ;; too many basic blocks ; (:methods ; (dummy-9 () none 9) ; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; (dummy-24 () none 24) -; (dummy-25 () none 25) -; (dummy-26 () none 26) -; (dummy-27 () none 27) -; (dummy-28 () none 28) -; (dummy-29 () none 29) -; (dummy-30 () none 30) -; (dummy-31 () none 31) -; (dummy-32 () none 32) -; (dummy-33 () none 33) -; (dummy-34 () none 34) -; (dummy-35 () none 35) -; (dummy-36 () none 36) -; (dummy-37 () none 37) -; (dummy-38 () none 38) -; (dummy-39 () none 39) -; (dummy-40 () none 40) -; (dummy-41 () none 41) -; (dummy-42 () none 42) -; (dummy-43 () none 43) -; (dummy-44 () none 44) -; (dummy-45 () none 45) -; (dummy-46 () none 46) -; (dummy-47 () none 47) -; (dummy-48 () none 48) -; (dummy-49 () none 49) -; (dummy-50 () none 50) -; (dummy-51 () none 51) -; (dummy-52 () none 52) ; ) ; ) +;; task-control-h +(deftype task-cstage (structure) + ((game-task uint8 :offset-assert 0) + (status uint64 :offset-assert 8) + (flags uint8 :offset-assert 16) + (condition basic :offset-assert 20) + ) + :method-count-assert 16 + :size-assert #x18 + :flag-assert #x1000000018 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + ) + ) + +;; task-control-h +(deftype task-control (basic) + ((current-stage int16 :offset-assert 4) + (stage basic :offset-assert 8) + ) + :method-count-assert 19 + :size-assert #xc + :flag-assert #x130000000c + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + ) + ) + +;; task-control-h +(deftype ambient-control (structure) + ((last-ambient-time uint64 :offset-assert 0) + (last-ambient basic :offset-assert 8) + (last-ambient-id uint32 :offset-assert 12) + ) + :method-count-assert 12 + :size-assert #x10 + :flag-assert #xc00000010 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + ) + ) + +;; task-control-h +(deftype process-taskable (process-drawable) + ((~Ttasks basic :offset-assert 176) + (~Tquery gui-query :inline :offset-assert 180) + (~Told-target-pos transformq :inline :offset-assert 208) + (~Tcell-for-task uint8 :offset-assert 256) + (~Tcell-x uint64 :offset-assert 264) + (~Tcam-joint-index int32 :offset-assert 272) + (~Tskippable basic :offset-assert 276) + (~Tblend-on-exit basic :offset-assert 280) + (~Tcamera uint64 :offset-assert 288) + (~Twill-talk basic :offset-assert 296) + (~Ttalk-message uint32 :offset-assert 300) + (~Tlast-talk uint64 :offset-assert 304) + (~Tbounce-away basic :offset-assert 312) + (~Tambient ambient-control :inline :offset-assert 320) + (~Tcenter-joint-index int32 :offset-assert 336) + (~Tdraw-bounds-y-offset float :offset-assert 340) + (~Tneck-joint-index int32 :offset-assert 344) + (~Tfuel-cell-anim basic :offset-assert 348) + (~Tsound-flava uint8 :offset-assert 352) + (~Thave-flava basic :offset-assert 356) + (~Tmusic basic :offset-assert 360) + (~Thave-music basic :offset-assert 364) + (~Tbeen-kicked basic :offset-assert 368) + (~Tcur-trans-hook basic :offset-assert 372) + (~Tshadow-backup basic :offset-assert 376) + ) + :heap-base #x110 + :method-count-assert 53 + :size-assert #x17c + :flag-assert #x350110017c + ;; inherited inpspect of process-drawable + (:methods + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + (dummy-27 () none 27) + (dummy-28 () none 28) + (dummy-29 () none 29) + (dummy-30 () none 30) + (dummy-31 () none 31) + (dummy-32 () none 32) + (dummy-33 () none 33) + (dummy-34 () none 34) + (dummy-35 () none 35) + (dummy-36 () none 36) + (dummy-37 () none 37) + (dummy-38 () none 38) + (dummy-39 () none 39) + (dummy-40 () none 40) + (dummy-41 () none 41) + (dummy-42 () none 42) + (dummy-43 () none 43) + (dummy-44 () none 44) + (dummy-45 () none 45) + (dummy-46 () none 46) + (dummy-47 () none 47) + (dummy-48 () none 48) + (dummy-49 () none 49) + (dummy-50 () none 50) + (dummy-51 () none 51) + (dummy-52 () none 52) + ) + ) + ; ;; game-save ; (deftype game-save-tag (structure) ; ((user-object UNKNOWN 2 :offset-assert 0) @@ -11855,268 +11690,268 @@ ; ) ; ) -; ;; game-save -; (deftype auto-save (process) -; ((~Tcard int32 :offset-assert 112) -; (~Tslot int32 :offset-assert 116) -; (~Twhich int32 :offset-assert 120) -; (~Tbuffer kheap :offset-assert 124) -; (~Tmode basic :offset-assert 128) -; (~Tresult uint32 :offset-assert 132) -; (~Tsave basic :offset-assert 136) -; (~Tinfo mc-slot-info :inline :offset-assert 140) -; (~Tnotify uint64 :offset-assert 440) -; (~Tstate-time uint64 :offset-assert 448) -; (~Tpart basic :offset-assert 456) -; ) -; :method-count-assert 23 -; :size-assert #x1cc -; :flag-assert #x17016001cc -; ;; inherited inpspect of process -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; ) -; ) +;; game-save +(deftype auto-save (process) + ((~Tcard int32 :offset-assert 112) + (~Tslot int32 :offset-assert 116) + (~Twhich int32 :offset-assert 120) + (~Tbuffer kheap :offset-assert 124) + (~Tmode basic :offset-assert 128) + (~Tresult uint32 :offset-assert 132) + (~Tsave basic :offset-assert 136) + (~Tinfo mc-slot-info :inline :offset-assert 140) + (~Tnotify uint64 :offset-assert 440) + (~Tstate-time uint64 :offset-assert 448) + (~Tpart basic :offset-assert 456) + ) + :heap-base #x160 + :method-count-assert 23 + :size-assert #x1cc + :flag-assert #x17016001cc + ;; inherited inpspect of process + (:methods + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + ) + ) -; ;; mood -; (deftype flames-state (structure) -; ((index uint8 :offset-assert 0) -; (time uint8 :offset-assert 1) -; (length uint8 :offset-assert 2) -; (height uint8 :offset-assert 3) -; ) -; :method-count-assert 9 -; :size-assert #x4 -; :flag-assert #x900000004 -; ) +;; mood +(deftype flames-state (structure) + ((index uint8 :offset-assert 0) + (time uint8 :offset-assert 1) + (length uint8 :offset-assert 2) + (height uint8 :offset-assert 3) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) -; ;; mood -; (deftype lightning-state (structure) -; ((val uint8 :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x1 -; :flag-assert #x900000001 -; ) +;; mood +(deftype lightning-state (structure) + ((val uint8 :offset-assert 0) + ) + :pack-me + :method-count-assert 9 + :size-assert #x1 + :flag-assert #x900000001 + ) -; ;; mood -; (deftype light-time-state (structure) -; ((time uint8 :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x1 -; :flag-assert #x900000001 -; ) +;; mood +(deftype light-time-state (structure) + ((time uint8 :offset-assert 0) + ) + :pack-me + :method-count-assert 9 + :size-assert #x1 + :flag-assert #x900000001 + ) -; ;; mood -; (deftype light-state (structure) -; ((fade uint8 :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x1 -; :flag-assert #x900000001 -; ) +;; mood +(deftype light-state (structure) + ((fade uint8 :offset-assert 0) + ) + :pack-me + :method-count-assert 9 + :size-assert #x1 + :flag-assert #x900000001 + ) -; ;; mood -; (deftype lava-state (structure) -; ((scale UNKNOWN 4 :offset-assert 0) -; (time uint8 :offset-assert 16) -; (last-index uint8 :offset-assert 17) -; ) -; :method-count-assert 9 -; :size-assert #x12 -; :flag-assert #x900000012 -; ) +;; mood +(deftype lava-state (structure) + ((scale float 4 :offset-assert 0) + (time uint8 :offset-assert 16) + (last-index uint8 :offset-assert 17) + ) + :pack-me + :method-count-assert 9 + :size-assert #x12 + :flag-assert #x900000012 + ) -; ;; mood -; (deftype misty-states (structure) -; ((flames flames-state :inline :offset-assert 0) -; (light0 light-state :inline :offset-assert 4) -; (light1 light-state :inline :offset-assert 5) -; (time0 light-time-state :inline :offset-assert 6) -; (time1 light-time-state :inline :offset-assert 7) -; ) -; :method-count-assert 9 -; :size-assert #x8 -; :flag-assert #x900000008 -; ) +;; mood +(deftype misty-states (structure) + ((flames flames-state :inline :offset-assert 0) + (light0 light-state :inline :offset-assert 4) + (light1 light-state :inline :offset-assert 5) + (time0 light-time-state :inline :offset-assert 6) + (time1 light-time-state :inline :offset-assert 7) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) -; ;; mood -; (deftype swamp-village2-states (structure) -; ((flames flames-state :inline :offset-assert 0) -; (lightning lightning-state :inline :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #x5 -; :flag-assert #x900000005 -; ) +;; mood +(deftype swamp-village2-states (structure) + ((flames flames-state :inline :offset-assert 0) + (lightning lightning-state :inline :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x5 + :flag-assert #x900000005 + ) -; ;; mood -; (deftype village1-states (structure) -; ((flames flames-state :inline :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x4 -; :flag-assert #x900000004 -; ) +;; mood +(deftype village1-states (structure) + ((flames flames-state :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) -; ;; mood -; (deftype jungle-states (structure) -; ((light light-state :inline :offset-assert 0) -; (time light-time-state :inline :offset-assert 1) -; (one-shot uint8 :offset-assert 2) -; ) -; :method-count-assert 9 -; :size-assert #x3 -; :flag-assert #x900000003 -; ) +;; mood +(deftype jungle-states (structure) + ((light light-state :inline :offset-assert 0) + (time light-time-state :inline :offset-assert 1) + (one-shot uint8 :offset-assert 2) + ) + :method-count-assert 9 + :size-assert #x3 + :flag-assert #x900000003 + ) -; ;; mood -; (deftype sunken-states (structure) -; ((light light-state :inline :offset-assert 0) -; (time light-time-state :inline :offset-assert 1) -; ) -; :method-count-assert 9 -; :size-assert #x2 -; :flag-assert #x900000002 -; ) +;; mood +(deftype sunken-states (structure) + ((light light-state :inline :offset-assert 0) + (time light-time-state :inline :offset-assert 1) + ) + :method-count-assert 9 + :size-assert #x2 + :flag-assert #x900000002 + ) -; ;; mood -; (deftype rolling-states (structure) -; ((light0 light-state :inline :offset-assert 0) -; (light1 light-state :inline :offset-assert 1) -; (light2 light-state :inline :offset-assert 2) -; (light3 light-state :inline :offset-assert 3) -; (time light-time-state :inline :offset-assert 4) -; (lightning lightning-state :inline :offset-assert 5) -; ) -; :method-count-assert 9 -; :size-assert #x6 -; :flag-assert #x900000006 -; ) +;; mood +(deftype rolling-states (structure) + ((light0 light-state :inline :offset-assert 0) + (light1 light-state :inline :offset-assert 1) + (light2 light-state :inline :offset-assert 2) + (light3 light-state :inline :offset-assert 3) + (time light-time-state :inline :offset-assert 4) + (lightning lightning-state :inline :offset-assert 5) + ) + :method-count-assert 9 + :size-assert #x6 + :flag-assert #x900000006 + ) -; ;; mood -; (deftype firecanyon-states (structure) -; ((lava lava-state :inline :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x12 -; :flag-assert #x900000012 -; ) +;; mood +(deftype firecanyon-states (structure) + ((lava lava-state :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x12 + :flag-assert #x900000012 + ) -; ;; mood -; (deftype training-states (structure) -; ((light light-state :inline :offset-assert 0) -; (time light-time-state :inline :offset-assert 1) -; ) -; :method-count-assert 9 -; :size-assert #x2 -; :flag-assert #x900000002 -; ) +;; mood +(deftype training-states (structure) + ((light light-state :inline :offset-assert 0) + (time light-time-state :inline :offset-assert 1) + ) + :method-count-assert 9 + :size-assert #x2 + :flag-assert #x900000002 + ) -; ;; mood -; (deftype maincave-states (structure) -; ((flames flames-state :inline :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x4 -; :flag-assert #x900000004 -; ) +;; mood +(deftype maincave-states (structure) + ((flames flames-state :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) -; ;; mood -; (deftype robocave-states (structure) -; ((flames flames-state :inline :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x4 -; :flag-assert #x900000004 -; ) +;; mood +(deftype robocave-states (structure) + ((flames flames-state :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) -; ;; mood -; (deftype snow-states (structure) -; ((flames flames-state :inline :offset-assert 0) -; (light light-state :inline :offset-assert 4) -; (time light-time-state :inline :offset-assert 5) -; (one-shot uint8 :offset-assert 6) -; (interp float :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; mood +(deftype snow-states (structure) + ((flames flames-state :inline :offset-assert 0) + (light light-state :inline :offset-assert 4) + (time light-time-state :inline :offset-assert 5) + (one-shot uint8 :offset-assert 6) + (interp float :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) -; ;; mood -; (deftype village3-states (structure) -; ((flames flames-state :inline :offset-assert 0) -; (scale float :offset-assert 4) -; (lava lava-state :inline :offset-assert 8) -; (lava-time float :offset-assert 28) -; (time uint8 :offset-assert 32) -; ) -; :method-count-assert 9 -; :size-assert #x21 -; :flag-assert #x900000021 -; ) +;; mood +(deftype village3-states (structure) + ((flames flames-state :inline :offset-assert 0) + (scale float :offset-assert 4) + (lava lava-state :inline :offset-assert 8) + (lava-time float :offset-assert 28) + (time uint8 :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x21 + :flag-assert #x900000021 + ) -; ;; mood -; (deftype lavatube-states (structure) -; ((lava lava-state :inline :offset-assert 0) -; (light light-state :inline :offset-assert 18) -; (time light-time-state :inline :offset-assert 19) -; ) -; :method-count-assert 9 -; :size-assert #x14 -; :flag-assert #x900000014 -; ) +;; mood +(deftype lavatube-states (structure) + ((lava lava-state :inline :offset-assert 0) + (light light-state :inline :offset-assert 18) + (time light-time-state :inline :offset-assert 19) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) -; ;; mood -; (deftype ogre-states (structure) -; ((lava lava-state :inline :offset-assert 0) -; (lightning lightning-state :inline :offset-assert 18) -; (lava-time float :offset-assert 20) -; (lava-fade float :offset-assert 24) -; ) -; :method-count-assert 9 -; :size-assert #x1c -; :flag-assert #x90000001c -; ) +;; mood +(deftype ogre-states (structure) + ((lava lava-state :inline :offset-assert 0) + (lightning lightning-state :inline :offset-assert 18) + (lava-time float :offset-assert 20) + (lava-fade float :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) -; ;; mood -; (deftype finalboss-states (structure) -; ((start-time uint64 :offset-assert 0) -; (secret-time uint64 :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; mood +(deftype finalboss-states (structure) + ((start-time uint64 :offset-assert 0) + (secret-time uint64 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) -; ;; mood -; (deftype citadel-states (structure) -; ((flames flames-state :inline :offset-assert 0) -; (light light-state :inline :offset-assert 4) -; (time light-time-state :inline :offset-assert 5) -; (flicker-off uint8 :offset-assert 6) -; (flicker-on uint8 :offset-assert 7) -; (shield-fade float :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; mood +(deftype citadel-states (structure) + ((flames flames-state :inline :offset-assert 0) + (light light-state :inline :offset-assert 4) + (time light-time-state :inline :offset-assert 5) + (flicker-off uint8 :offset-assert 6) + (flicker-on uint8 :offset-assert 7) + (shield-fade float :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) ; ;; sky ; (deftype sky-frame-data (structure) @@ -12150,71 +11985,72 @@ ; ;; bad type dec string: sky-vertex [~X]:~% ; ) -; ;; load-boundary-h -; (deftype lbvtx (structure) -; ((x float :offset-assert 0) -; (y float :offset-assert 4) -; (z float :offset-assert 8) -; (v0 uint8 :offset-assert 12) -; (v1 uint8 :offset-assert 13) -; (v2 uint8 :offset-assert 14) -; (ix uint8 :offset-assert 15) -; (quad uint128 :offset-assert 0) -; (v vector :inline :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; load-boundary-h +(deftype lbvtx (structure) + ((x float :offset-assert 0) + (y float :offset-assert 4) + (z float :offset-assert 8) + (v0 uint8 :offset-assert 12) + (v1 uint8 :offset-assert 13) + (v2 uint8 :offset-assert 14) + (ix uint8 :offset-assert 15) + (quad uint128 :offset 0) + (v vector :inline :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) ; ;; load-boundary-h -; (deftype load-boundary-crossing-command (structure) -; ((cmd uint8 :offset-assert 0) -; (bparm UNKNOWN 3 :offset-assert 1) -; (parm UNKNOWN 2 :offset-assert 4) -; (lev0 basic :offset-assert 4) -; (lev1 basic :offset-assert 8) -; (displev basic :offset-assert 4) -; (dispcmd basic :offset-assert 8) -; (nick basic :offset-assert 4) -; (forcelev basic :offset-assert 4) -; (forceonoff basic :offset-assert 8) -; (checkname basic :offset-assert 4) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +(deftype load-boundary-crossing-command (structure) + ((cmd uint8 :offset-assert 0) + (bparm uint8 3 :offset-assert 1) + ;(parm UNKNOWN 2 :offset-assert 4) + (lev0 basic :offset-assert 4) + (lev1 basic :offset-assert 8) + (displev basic :offset 4) + (dispcmd basic :offset 8) + (nick basic :offset 4) + (forcelev basic :offset 4) + (forceonoff basic :offset 8) + (checkname basic :offset 4) + ) + :pack-me + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) -; ;; load-boundary-h -; (deftype load-boundary (basic) -; ((num-points uint16 :offset-assert 4) -; (flags uint8 :offset-assert 6) -; (top-plane float :offset-assert 8) -; (bot-plane float :offset-assert 12) -; (tri-cnt int32 :offset-assert 16) -; (next basic :offset-assert 20) -; (cmd-fwd load-boundary-crossing-command :inline :offset-assert 24) -; (cmd-bwd load-boundary-crossing-command :inline :offset-assert 36) -; (rejector vector :inline :offset-assert 48) -; (data UNKNOWN 1 :offset-assert 64) -; ) -; :method-count-assert 9 -; :size-assert #x50 -; :flag-assert #x900000050 -; ) +;; load-boundary-h +(deftype load-boundary (basic) + ((num-points uint16 :offset-assert 4) + (flags uint8 :offset-assert 6) + (top-plane float :offset-assert 8) + (bot-plane float :offset-assert 12) + (tri-cnt int32 :offset-assert 16) + (next basic :offset-assert 20) + (cmd-fwd load-boundary-crossing-command :inline :offset-assert 24) + (cmd-bwd load-boundary-crossing-command :inline :offset-assert 36) + (rejector vector :inline :offset-assert 48) + (data uint128 1 :offset-assert 64) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) -; ;; load-boundary -; (deftype lb-editor-parms (basic) -; ((boundary basic :offset-assert 4) -; (vertex int32 :offset-assert 8) -; (x-origin float :offset-assert 12) -; (z-origin float :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x14 -; :flag-assert #x900000014 -; ) +;; load-boundary +(deftype lb-editor-parms (basic) + ((boundary basic :offset-assert 4) + (vertex int32 :offset-assert 8) + (x-origin float :offset-assert 12) + (z-origin float :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) ; ;; text ; (deftype game-text-info (basic) @@ -12228,54 +12064,54 @@ ; ) ; ) -; ;; 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 -; ) +;; 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 + ) -; ;; collide-probe -; (deftype collide-probe-stack (structure) -; ((data UNKNOWN 1024 :offset-assert 0) -; ) -; :method-count-assert 9 -; :size-assert #x4000 -; :flag-assert #x900004000 -; ) +;; collide-probe +(deftype collide-probe-stack (structure) + ((data collide-probe-stack-elem 1024 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x4000 + :flag-assert #x900004000 + ) -; ;; 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 -; ) +;; 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 + ) -; ;; collide-mesh -; (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 -; ) +;; collide-mesh +(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 + ) -; ;; collide-mesh -; (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 -; ) +;; collide-mesh +(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 + ) ; ;; collide-touch ; (deftype add-prims-touching-work (structure) @@ -12299,18 +12135,18 @@ ; :flag-assert #x900000030 ; ) -; ;; merc-death -; (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 basic :offset-assert 12) -; ) -; :method-count-assert 9 -; :size-assert #x10 -; :flag-assert #x900000010 -; ) +;; merc-death +(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 basic :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) ; ;; water-h ; (deftype water-control (basic) @@ -14107,6 +13943,12 @@ ; ;; unrecognized get op: (set! v1 process) parent was UNKNOWN ; ) +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; COMMON TYPES ;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; + ; ;; rigid-body-h ; (deftype rigid-body (structure) ; ((mass float :offset-assert 0) @@ -15210,6 +15052,12 @@ ; ) ; ) +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; BEA TYPES ;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; + ; ;; mistycannon ; (deftype angle-tracker (structure) ; ((value float :offset-assert 0) @@ -16331,6 +16179,12 @@ ; ) ; ) +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; CIT TYPES ;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; + ; ;; villagep-obs ; (deftype warpgate (process-hidden) ; ((name basic :offset-assert 4) @@ -18273,6 +18127,12 @@ ; ) ; ) +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; DAR TYPES ;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~; + ; ;; darkcave-obs ; (deftype cavecrystal (process-drawable) ; ((~Tis-master? basic :offset-assert 176) @@ -30946,65 +30806,45 @@ ; ) ; ) -; ;; title-obs -; (deftype logo (process-drawable) -; ((~Tcamera uint64 :offset-assert 176) -; (~Tcamera-anim uint64 :offset-assert 184) -; (~Tvolumes uint64 :offset-assert 192) -; (~Tblack uint64 :offset-assert 200) -; (~Ttarget uint64 :offset-assert 208) -; (~Tsidekick uint64 :offset-assert 216) -; (~Tmain-joint basic :offset-assert 224) -; (~Tanim basic :offset-assert 228) -; (~Tnext-anim basic :offset-assert 232) -; (~Tdone? basic :offset-assert 236) -; ) -; :method-count-assert 24 -; :size-assert #xf0 -; :flag-assert #x18008000f0 -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; ) -; ) +;; title-obs +(deftype logo (process-drawable) + ((~Tcamera uint64 :offset-assert 176) + (~Tcamera-anim uint64 :offset-assert 184) + (~Tvolumes uint64 :offset-assert 192) + (~Tblack uint64 :offset-assert 200) + (~Ttarget uint64 :offset-assert 208) + (~Tsidekick uint64 :offset-assert 216) + (~Tmain-joint basic :offset-assert 224) + (~Tanim basic :offset-assert 228) + (~Tnext-anim basic :offset-assert 232) + (~Tdone? basic :offset-assert 236) + ) + :heap-base #x80 + :method-count-assert 24 + :size-assert #xf0 + :flag-assert #x18008000f0 + ;; inherited inpspect of process-drawable + (:methods + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + ) + ) -; ;; title-obs -; (deftype logo-slave (process-drawable) -; ((~Tmain-joint basic :offset-assert 176) -; ) -; :method-count-assert 21 -; :size-assert #xb4 -; :flag-assert #x15005000b4 -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; ) -; ) +;; title-obs +(deftype logo-slave (process-drawable) + ((~Tmain-joint basic :offset-assert 176) + ) + :heap-base #x50 + :method-count-assert 21 + :size-assert #xb4 + :flag-assert #x15005000b4 + ;; inherited inpspect of process-drawable + (:methods + (dummy-20 () none 20) + ) + ) ; ;; lava ; (deftype lava (water-anim) From acb91dbf48fd8c22a4b766999e06e7746b168327 Mon Sep 17 00:00:00 2001 From: water Date: Sun, 25 Oct 2020 18:02:03 -0400 Subject: [PATCH 3/3] some work on vector types --- common/goos/Object.h | 8 + decompiler/config/all-types.gc | 308 +++++++++---------- doc/changelog.md | 6 +- goal_src/engine/math/vector-h.gc | 426 ++++++++++++++++++++++++++ goalc/compiler/Compiler.h | 2 + goalc/compiler/Util.cpp | 11 + goalc/compiler/compilation/Static.cpp | 8 + goalc/compiler/compilation/Type.cpp | 33 +- 8 files changed, 625 insertions(+), 177 deletions(-) diff --git a/common/goos/Object.h b/common/goos/Object.h index 13b0e2584d..aca66b059b 100644 --- a/common/goos/Object.h +++ b/common/goos/Object.h @@ -300,6 +300,14 @@ class Object { return float_obj.value; } + const FloatType& as_float() const { + if (type != ObjectType::FLOAT) { + throw std::runtime_error("as_float called on a " + object_type_to_string(type) + " " + + print()); + } + return float_obj.value; + } + char& as_char() { if (type != ObjectType::CHAR) { throw std::runtime_error("as_char called on a " + object_type_to_string(type) + " " + diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc index 8be0462c20..3ec673dd38 100644 --- a/decompiler/config/all-types.gc +++ b/decompiler/config/all-types.gc @@ -12200,77 +12200,61 @@ ; ) ; ) -; ;; water-h -; (deftype water-vol (process-drawable) -; ((~Twater-height meters :offset-assert 176) -; (~Twade-height meters :offset-assert 180) -; (~Tswim-height meters :offset-assert 184) -; (~Tbottom-height meters :offset-assert 188) -; (~Tattack-event basic :offset-assert 192) -; (~Ttarget uint64 :offset-assert 200) -; (~Tflags uint32 :offset-assert 208) -; ) -; :method-count-assert 30 -; :size-assert #xd4 -; :flag-assert #x1e007000d4 -; ;; inherited inpspect of process-drawable -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; (dummy-14 () none 14) -; (dummy-15 () none 15) -; (dummy-16 () none 16) -; (dummy-17 () none 17) -; (dummy-18 () none 18) -; (dummy-19 () none 19) -; (dummy-20 () none 20) -; (dummy-21 () none 21) -; (dummy-22 () none 22) -; (dummy-23 () none 23) -; (dummy-24 () none 24) -; (dummy-25 () none 25) -; (dummy-26 () none 26) -; (dummy-27 () none 27) -; (dummy-28 () none 28) -; (dummy-29 () none 29) -; ) -; ) +;; water-h +(deftype water-vol (process-drawable) + ((~Twater-height float :offset-assert 176) ;; meters + (~Twade-height float :offset-assert 180) ;; meters + (~Tswim-height float :offset-assert 184) ;; meters + (~Tbottom-height float :offset-assert 188) ;; meters + (~Tattack-event basic :offset-assert 192) + (~Ttarget uint64 :offset-assert 200) + (~Tflags uint32 :offset-assert 208) + ) + :heap-base #x70 + :method-count-assert 30 + :size-assert #xd4 + :flag-assert #x1e007000d4 + ;; inherited inpspect of process-drawable + (:methods + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + (dummy-27 () none 27) + (dummy-28 () none 28) + (dummy-29 () none 29) + ) + ) -; ;; cam-master -; (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 -; ) +;; cam-master +(deftype camera-master-bank (basic) + ((onscreen-head-height float :offset-assert 4) ;; meters + (onscreen-foot-height float :offset-assert 8) ;; meters + (target-height float :offset-assert 12) ;; meters + (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 + ) -; ;; cam-master -; (deftype list-keeper (process) -; ((~Tdummy float :offset-assert 112) -; ) -; :method-count-assert 14 -; :size-assert #x74 -; :flag-assert #xe00100074 -; ;; inherited inpspect of process -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; (dummy-12 () none 12) -; (dummy-13 () none 13) -; ) -; ) +;; cam-master +(deftype list-keeper (process) + ((~Tdummy float :offset-assert 112) + ) + :heap-base #x10 + :method-count-assert 14 + :size-assert #x74 + :flag-assert #xe00100074 + ;; inherited inpspect of process + ) ; ;; cam-states ; (deftype cam-eye-bank (UNKNOWN) @@ -12344,82 +12328,82 @@ ; ;; bad get label ; ) -; ;; cam-states-dbg -; (deftype cam-point-watch-bank (basic) -; ((speed float :offset-assert 4) -; (rot-speed deg :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; cam-states-dbg +(deftype cam-point-watch-bank (basic) + ((speed float :offset-assert 4) + (rot-speed float :offset-assert 8) ;; deg + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) -; ;; cam-states-dbg -; (deftype cam-free-bank (basic) -; ((speed float :offset-assert 4) -; (rot-speed deg :offset-assert 8) -; ) -; :method-count-assert 9 -; :size-assert #xc -; :flag-assert #x90000000c -; ) +;; cam-states-dbg +(deftype cam-free-bank (basic) + ((speed float :offset-assert 4) + (rot-speed float :offset-assert 8) ;; deg + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) -; ;; cam-states-dbg -; (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 -; ) +;; cam-states-dbg +(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 + ) -; ;; cam-states-dbg -; (deftype camera-orbit-info (structure) -; ((radius float :offset-assert 0) -; (rot float :offset-assert 4) -; (target-off vector :inline :offset-assert 16) -; (orbit-off vector :inline :offset-assert 32) -; (radius-lerp float :offset-assert 48) -; ) -; :method-count-assert 9 -; :size-assert #x34 -; :flag-assert #x900000034 -; ) +;; cam-states-dbg +(deftype camera-orbit-info (structure) + ((radius float :offset-assert 0) + (rot float :offset-assert 4) + (target-off vector :inline :offset-assert 16) + (orbit-off vector :inline :offset-assert 32) + (radius-lerp float :offset-assert 48) + ) + :method-count-assert 9 + :size-assert #x34 + :flag-assert #x900000034 + ) -; ;; cam-states-dbg -; (deftype CAM_ORBIT-bank (basic) -; ((RADIUS_MAX float :offset-assert 4) -; (RADIUS_MIN float :offset-assert 8) -; (TARGET_OFF_ADJUST float :offset-assert 12) -; (ORBIT_OFF_ADJUST float :offset-assert 16) -; ) -; :method-count-assert 9 -; :size-assert #x14 -; :flag-assert #x900000014 -; ) +;; cam-states-dbg +(deftype CAM_ORBIT-bank (basic) + ((RADIUS_MAX float :offset-assert 4) + (RADIUS_MIN float :offset-assert 8) + (TARGET_OFF_ADJUST float :offset-assert 12) + (ORBIT_OFF_ADJUST float :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) -; ;; vol-h -; (deftype plane-volume (structure) -; ((volume-type basic :offset-assert 0) -; (point-count int16 :offset-assert 4) -; (normal-count int16 :offset-assert 6) -; (first-point vector :offset-assert 8) -; (first-normal vector :offset-assert 12) -; (num-planes int32 :offset-assert 16) -; (plane uint32 :offset-assert 20) -; ) -; :method-count-assert 12 -; :size-assert #x18 -; :flag-assert #xc00000018 -; (:methods -; (dummy-9 () none 9) -; (dummy-10 () none 10) -; (dummy-11 () none 11) -; ) -; ) +;; vol-h +(deftype plane-volume (structure) + ((volume-type basic :offset-assert 0) + (point-count int16 :offset-assert 4) + (normal-count int16 :offset-assert 6) + (first-point vector :offset-assert 8) + (first-normal vector :offset-assert 12) + (num-planes int32 :offset-assert 16) + (plane uint32 :offset-assert 20) + ) + :method-count-assert 12 + :size-assert #x18 + :flag-assert #xc00000018 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + ) + ) ; ;; vol-h ; (deftype vol-control (basic) @@ -12576,28 +12560,28 @@ ; :flag-assert #x900000044 ; ) -; ;; cam-debug -; (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 basic :offset-assert 164) -; ) -; :method-count-assert 9 -; :size-assert #xa8 -; :flag-assert #x9000000a8 -; ) +;; cam-debug +(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 basic :offset-assert 164) + ) + :method-count-assert 9 + :size-assert #xa8 + :flag-assert #x9000000a8 + ) ; ;; cam-debug ; (deftype cam-collision-record-array (inline-array-class) diff --git a/doc/changelog.md b/doc/changelog.md index 86149b81a5..aa7ea5a5dc 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -39,4 +39,8 @@ - The `&+` form now accepts more than two arguments. - The `&+` form now works on `inline-array` and `structure`. - In the case where the type system would use a result type of `lca(none, x)`, the result type is now `none` instead of compiler abort. -- The "none value" is now `(none)` instead of `none` \ No newline at end of file +- The "none value" is now `(none)` instead of `none` + +- Creating a field of 128-bit value type no longer causes a compiler crash +- 128-bit fields are inspected as `` +- Static fields can now contain floating point values \ No newline at end of file diff --git a/goal_src/engine/math/vector-h.gc b/goal_src/engine/math/vector-h.gc index c6c01ba0ee..5ca9f09394 100644 --- a/goal_src/engine/math/vector-h.gc +++ b/goal_src/engine/math/vector-h.gc @@ -5,3 +5,429 @@ ;; name in dgo: vector-h ;; dgos: GAME, ENGINE +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; bit array +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(deftype bit-array (basic) + ((length int32 :offset-assert 4) + (allocated-length int32 :offset-assert 8) + (_pad uint8) + ) + :method-count-assert 13 + :size-assert #xd + :flag-assert #xd0000000d + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) + +;; todo new +;; todo 4 +;; todo 5 +;; todo 9 +;; todo 10 +;; todo 11 +;; todo 12 +;; + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; vector types (integer) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Vector of 4 unsigned bytes. +(deftype vector4ub (structure) + ((data uint8 4 :offset-assert 0) + (x uint8 :offset 0) + (y uint8 :offset 1) + (z uint8 :offset 2) + (w uint8 :offset 3) + (clr uint32 :offset 0) + ) + :pack-me + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +;; Vector of 4 signed bytes +(deftype vector4b (structure) + ((data int8 4 :offset-assert 0) + (x int8 :offset 0) + (y int8 :offset 1) + (z int8 :offset 2) + (w int8 :offset 3) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +;; Vector of 2 signed halfwords +(deftype vector2h (structure) + ((data int16 2 :offset-assert 0) + (x int16 :offset 0) + (y int16 :offset 2) + ) + :pack-me + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +;; Vector of 2 unsigned halfwords +(deftype vector2uh (structure) + ((data uint16 2 :offset-assert 0) + (x uint16 :offset 0) + (y uint16 :offset 2) + (val uint32 :offset 0) + ) + :pack-me + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +;; Vector of 3 halfwords +(deftype vector3h (structure) + ((data int16 2 :offset-assert 0) ;; probably a bug, should be 3. + (x int16 :offset 0) + (y int16 :offset 2) + (z int16 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x6 + :flag-assert #x900000006 + ) + +;; Vector of 2 signed words +(deftype vector2w (structure) + ((data int32 2 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) + ) + :pack-me + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; Vector of 3 signed words +(deftype vector3w (structure) + ((data int32 3 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) + (z int32 :offset 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +;; Vector of 4 signed words +(deftype vector4w (structure) + ((data int32 4 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) + (z int32 :offset 8) + (w int32 :offset 12) + (dword uint64 2 :offset 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(defmethod print vector4w ((this vector4w)) + (format #t "#" + (-> this data 0) + (-> this data 1) + (-> this data 2) + (-> this data 3) + this) + this + ) + +;; Two vector4w's +(deftype vector4w-2 (structure) + ((data int32 8 :offset-assert 0) + (quad uint128 2 :offset 0) + (vector vector4w 2 :offset 0) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; Three vector4w's +(deftype vector4w-3 (structure) + ((data int32 12 :offset-assert 0) + (quad uint128 3 :offset 0) + (vector vector4w 3 :offset 0) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +;; Four vector4w's +(deftype vector4w-4 (structure) + ((data int32 16 :offset-assert 0) + (quad uint128 4 :offset 0) + (vector vector4w 4 :offset 0) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +;; Vector of 4 halfwords +(deftype vector4h (structure) + ((data int16 4 :offset-assert 0) + (x int16 :offset 0) + (y int16 :offset 2) + (z int16 :offset 4) + (w int16 :offset 6) + (long uint64 :offset 0) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; Vector of 8 halfwords +(deftype vector8h (structure) + ((data int16 8 :offset-assert 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; Vector of 16 signed bytes +(deftype vector16b (structure) + ((data int8 8 :offset-assert 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; vector types (floating point) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; Vector of 4 floats. Shortened to "vector" because it is commonly used. +(deftype vector (structure) + ((data float 4 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) + (w float :offset 12) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(defmethod inspect vector ((this vector)) + (format #t "[~8x] vector~%" this) + (format #t "~T[~F] [~F] [~F] [~F]~%" + (-> this data 0) + (-> this data 1) + (-> this data 2) + (-> this data 3)) + this) + +(defmethod print vector ((this vector)) + (format #t "#" + (-> this data 0) + (-> this data 1) + (-> this data 2) + (-> this data 3) + this) + this) + + +(define *null-vector* (new 'static 'vector :x 0. :y 0. :z 0. :w 1.)) +(define *identity-vector* (new 'static 'vector :x 1. :y 1. :z 1. :w 1.)) +(define *x-vector* (new 'static 'vector :x 1. :y 0. :z 0. :w 1.)) +(define *y-vector* (new 'static 'vector :x 0. :y 1. :z 0. :w 1.)) +(define *z-vector* (new 'static 'vector :x 0. :y 0. :z 1. :w 1.)) +(define *up-vector* (new 'static 'vector :x 0. :y 1. :z 0. :w 1.)) + + +;; Three vector's +(deftype vector4s-3 (structure) + ((data float 12 :offset-assert 0) ;; guess + (quad uint128 3 :offset 0) + (vector vector4w 3 :offset 0) ;; guess + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype vector-array (inline-array-class) + ( + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(set! (-> vector-array heap-base) 16) + +(deftype rgbaf (vector) + ((r float :offset 0) + (g float :offset 4) + (b float :offset 8) + (a float :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype plane (vector) + ((a float :offset 0) + (b float :offset 4) + (c float :offset 8) + (d float :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype sphere (vector) + ((r float :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +; (deftype isphere (vec4s) +; () +; :method-count-assert 9 +; :size-assert #x10 +; :flag-assert #x900000010 +; ) + +(deftype box8s (structure) + ((data float 8 :offset-assert 0) + (quad uint128 2 :offset 0) + (vector vector 2 :offset 0) + (min vector :inline :offset 0) + (max vector :inline :offset 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype box8s-array (inline-array-class) + () + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(set! (-> box8s-array heap-base) 32) + +(deftype cylinder (structure) + ((origin vector :inline :offset-assert 0) + (axis vector :inline :offset-assert 16) + (radius float :offset-assert 32) + (length float :offset-assert 36) + ) + :method-count-assert 11 + :size-assert #x28 + :flag-assert #xb00000028 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) + +(deftype cylinder-flat (structure) + ((origin vector :inline :offset-assert 0) + (axis vector :inline :offset-assert 16) + (radius float :offset-assert 32) + (length float :offset-assert 36) + ) + :method-count-assert 11 + :size-assert #x28 + :flag-assert #xb00000028 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) + +;; vector-h +(deftype vertical-planes (structure) + ((data uint128 4 :offset-assert 0) ;; probably wrong + ) + :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 16) ;; todo, why is this here? + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype qword (structure) + ((data uint32 4 :offset-assert 0) + (byte uint8 16 :offset 0) + (hword uint16 8 :offset 0) + (word uint32 4 :offset 0) + (dword uint64 2 :offset 0) + (quad uint128 :offset 0) + (vector vector :inline :offset 0) + (vector4w vector4w :inline :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype vector3s (structure) + ((data float 3 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +;; todo dot, dot-vu, 4-dot, 4-dot-vu, +!, -!, zero!, reset!, copy! + +; (defun vector-dot ((a vector) (b vector)) +; "Take the dot product of two vectors. +; Only does the x, y, z compoments" +; (let ((result 0.)) +; (+! result (* (-> a x) (-> b x))) +; (+! result (* (-> a y) (-> b y))) +; (+! result (* (-> a z) (-> b z))) +; ) +; result +; ) + +(define *zero-vector* (new 'static 'vector :x 0. :y 0. :z 0. :w 0.)) \ No newline at end of file diff --git a/goalc/compiler/Compiler.h b/goalc/compiler/Compiler.h index 34aa7cc813..049c2d99b1 100644 --- a/goalc/compiler/Compiler.h +++ b/goalc/compiler/Compiler.h @@ -94,6 +94,7 @@ class Compiler { const std::string& method_type_name = ""); bool try_getting_constant_integer(const goos::Object& in, int64_t* out, Env* env); + float try_getting_constant_float(const goos::Object& in, float* out, Env* env); TypeSystem m_ts; std::unique_ptr m_global_env = nullptr; @@ -189,6 +190,7 @@ class Compiler { // Math Val* compile_add(const goos::Object& form, const goos::Object& rest, Env* env); + Val* compile_sub(const goos::Object& form, const goos::Object& rest, Env* env); Val* compile_mul(const goos::Object& form, const goos::Object& rest, Env* env); Val* compile_div(const goos::Object& form, const goos::Object& rest, Env* env); diff --git a/goalc/compiler/Util.cpp b/goalc/compiler/Util.cpp index b3a805be69..40329ebdf7 100644 --- a/goalc/compiler/Util.cpp +++ b/goalc/compiler/Util.cpp @@ -215,6 +215,17 @@ bool Compiler::try_getting_constant_integer(const goos::Object& in, int64_t* out return true; } + // todo, try more things like constants before giving up. + return false; +} + +float Compiler::try_getting_constant_float(const goos::Object& in, float* out, Env* env) { + (void)env; + if (in.is_float()) { + *out = in.as_float(); + return true; + } + // todo, try more things like constants before giving up. return false; } \ No newline at end of file diff --git a/goalc/compiler/compilation/Static.cpp b/goalc/compiler/compilation/Static.cpp index e1eead7400..a8ea2dfbb4 100644 --- a/goalc/compiler/compilation/Static.cpp +++ b/goalc/compiler/compilation/Static.cpp @@ -119,6 +119,14 @@ Val* Compiler::compile_new_static_structure_or_basic(const goos::Object& form, throw_compile_error( form, "Setting a basic field to anything other than a symbol is currently unsupported"); } + } else if (is_float(field_info.type)) { + float value = 0.f; + if (!try_getting_constant_float(field_value, &value, env)) { + throw_compile_error(form, fmt::format("Field {} is a float, but the value given couldn't " + "be converted to a float at compile time.", + field_name_def)); + } + memcpy(obj->data.data() + field_offset, &value, sizeof(float)); } else { diff --git a/goalc/compiler/compilation/Type.cpp b/goalc/compiler/compilation/Type.cpp index ae2e07beba..478d07d411 100644 --- a/goalc/compiler/compilation/Type.cpp +++ b/goalc/compiler/compilation/Type.cpp @@ -111,6 +111,18 @@ void Compiler::generate_field_description(const goos::Object& form, if (m_ts.typecheck(m_ts.make_typespec("type"), f.type(), "", false, false)) { // type return; + } else if (f.is_array() && !f.is_dynamic()) { + // Arrays + str_template += fmt::format("~T{}[{}] @ #x~X~%", f.name(), f.array_size()); + format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); + } else if (f.is_dynamic()) { + // Dynamic Field + str_template += fmt::format("~T{}[0] @ #x~X~%", f.name()); + format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); + } else if (f.is_dynamic()) { + // Structure + str_template += fmt::format("~T{}: #<{} @ #x~X>~%", f.name(), f.type().print()); + format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); } else if (m_ts.typecheck(m_ts.make_typespec("basic"), f.type(), "", false, false) || m_ts.typecheck(m_ts.make_typespec("binteger"), f.type(), "", false, false) || m_ts.typecheck(m_ts.make_typespec("pair"), f.type(), "", false, false)) { @@ -119,8 +131,13 @@ void Compiler::generate_field_description(const goos::Object& form, format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); } else if (m_ts.typecheck(m_ts.make_typespec("integer"), f.type(), "", false, false)) { // Integer - str_template += fmt::format("~T{}: ~D~%", f.name()); - format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); + if (f.type().print() == "uint128") { + str_template += fmt::format("~T{}: ~%", f.name()); + } else { + str_template += fmt::format("~T{}: ~D~%", f.name()); + format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); + } + } else if (m_ts.typecheck(m_ts.make_typespec("float"), f.type(), "", false, false)) { // Float str_template += fmt::format("~T{}: ~f~%", f.name()); @@ -129,18 +146,6 @@ void Compiler::generate_field_description(const goos::Object& form, // Pointers str_template += fmt::format("~T{}: #x~X~%", f.name()); format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); - } else if (f.is_array() && !f.is_dynamic()) { - // Arrays - str_template += fmt::format("~T{}[{}] @ #x~X~%", f.name(), f.array_size()); - format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); - } else if (f.is_dynamic()) { - // Dynamic Field - str_template += fmt::format("~T{}[0] @ #x~X~%", f.name()); - format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); - } else if (f.is_dynamic()) { - // Structure - str_template += fmt::format("~T{}: #<{} @ #x~X>~%", f.name(), f.type().print()); - format_args.push_back(get_field_of_structure(type, reg, f.name(), env)->to_gpr(env)); } else { // Otherwise, we havn't implemented it! str_template += fmt::format("~T{}: Undefined!~%", f.name());