mirror of
https://github.com/open-goal/jak-project
synced 2026-05-31 09:22:14 -04:00
ManDude
324def1303
Moves PC-specific entity and debug menu things to `entity-debug.gc` and `default-menu-pc.gc` respectively and makes `(declare-file (debug))` work as it should (no need to wrap the entire file in `(when *debug-segment*` now!). Also changes the DGO descriptor format so that it's less verbose. It might break custom levels, but the format change is very simple so it should not be difficult for anyone to update to the new format. Sadly, you lose the completely useless ability to use DGO object names that don't match the source file name. The horror! I've also gone ahead and expanded the force envmap option to also force the ripple effect to be active. I did not notice any performance or visual drawbacks from this. Gets rid of some distracting LOD and some water pools appearing super flat (and pitch back for dark eco). Fixes #1424
1202 lines
40 KiB
Common Lisp
Vendored
Generated
1202 lines
40 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; this file is debug only
|
|
(declare-file (debug))
|
|
|
|
;; definition for symbol *editable-temp-id*, type int
|
|
(define *editable-temp-id* 0)
|
|
|
|
;; definition for function editable-command->string
|
|
(defun editable-command->string ((arg0 editable-command))
|
|
(case arg0
|
|
(((editable-command insert-entity))
|
|
"insert-entity"
|
|
)
|
|
(((editable-command print-region-info))
|
|
"print-region-info"
|
|
)
|
|
(((editable-command resize))
|
|
"resize"
|
|
)
|
|
(((editable-command insert-face))
|
|
"insert-face"
|
|
)
|
|
(((editable-command select-one))
|
|
"select-one"
|
|
)
|
|
(((editable-command update-game))
|
|
"update-game"
|
|
)
|
|
(((editable-command region-set))
|
|
"region-set"
|
|
)
|
|
(((editable-command select-all))
|
|
"select-all"
|
|
)
|
|
(((editable-command region-add))
|
|
"region-add"
|
|
)
|
|
(((editable-command flip-side))
|
|
"flip-side"
|
|
)
|
|
(((editable-command drag-resize))
|
|
"drag-resize"
|
|
)
|
|
(((editable-command select-current-prim))
|
|
"select-current-prim"
|
|
)
|
|
(((editable-command edit-plane-set))
|
|
"edit-plane-set"
|
|
)
|
|
(((editable-command edit-plane-clear))
|
|
"edit-plane-clear"
|
|
)
|
|
(((editable-command kill))
|
|
"kill"
|
|
)
|
|
(((editable-command delete-region))
|
|
"delete-region"
|
|
)
|
|
(((editable-command select-region))
|
|
"select-region"
|
|
)
|
|
(((editable-command camera-tumble))
|
|
"camera-tumble"
|
|
)
|
|
(((editable-command select-current-face))
|
|
"select-current-face"
|
|
)
|
|
(((editable-command snap-xz))
|
|
"snap-xz"
|
|
)
|
|
(((editable-command insert-sample))
|
|
"insert-sample"
|
|
)
|
|
(((editable-command camera-xy))
|
|
"camera-xy"
|
|
)
|
|
(((editable-command pick-loc))
|
|
"pick-loc"
|
|
)
|
|
(((editable-command select-face))
|
|
"select-face"
|
|
)
|
|
(((editable-command rotate-level))
|
|
"rotate-level"
|
|
)
|
|
(((editable-command pick-yes-no))
|
|
"pick-yes-no"
|
|
)
|
|
(((editable-command translate-y-level))
|
|
"translate-y-level"
|
|
)
|
|
(((editable-command save))
|
|
"save"
|
|
)
|
|
(((editable-command copy-region))
|
|
"copy-region"
|
|
)
|
|
(((editable-command cancel))
|
|
"cancel"
|
|
)
|
|
(((editable-command insert-light))
|
|
"insert-light"
|
|
)
|
|
(((editable-command drag-move-z))
|
|
"drag-move-z"
|
|
)
|
|
(((editable-command exit))
|
|
"exit"
|
|
)
|
|
(((editable-command drag-move-y))
|
|
"drag-move-y"
|
|
)
|
|
(((editable-command drag-move-xy))
|
|
"drag-move-xy"
|
|
)
|
|
(((editable-command select-prim))
|
|
"select-prim"
|
|
)
|
|
(((editable-command none))
|
|
"none"
|
|
)
|
|
(((editable-command delete))
|
|
"delete"
|
|
)
|
|
(((editable-command drag-move-x))
|
|
"drag-move-x"
|
|
)
|
|
(((editable-command insert-plane))
|
|
"insert-plane"
|
|
)
|
|
(((editable-command insert-sphere))
|
|
"insert-sphere"
|
|
)
|
|
(((editable-command insert-point))
|
|
"insert-point"
|
|
)
|
|
(((editable-command select-current-region))
|
|
"select-current-region"
|
|
)
|
|
(((editable-command camera-xz))
|
|
"camera-xz"
|
|
)
|
|
(((editable-command region-new))
|
|
"region-new"
|
|
)
|
|
(((editable-command drag-move-xz))
|
|
"drag-move-xz"
|
|
)
|
|
(((editable-command load))
|
|
"load"
|
|
)
|
|
(((editable-command insert-box))
|
|
"insert-box"
|
|
)
|
|
(((editable-command snap-to-ground))
|
|
"snap-to-ground"
|
|
)
|
|
(((editable-command select-none))
|
|
"select-none"
|
|
)
|
|
(((editable-command select-toggle))
|
|
"select-toggle"
|
|
)
|
|
(((editable-command insert-sample-camera))
|
|
"insert-sample-camera"
|
|
)
|
|
(((editable-command pick-target))
|
|
"pick-target"
|
|
)
|
|
(((editable-command select-current-owner))
|
|
"select-current-owner"
|
|
)
|
|
(((editable-command refresh-filter))
|
|
"refresh-filter"
|
|
)
|
|
(((editable-command copy))
|
|
"copy"
|
|
)
|
|
(((editable-command snap-y))
|
|
"snap-y"
|
|
)
|
|
(else
|
|
"*unknown*"
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function editable-filter->string
|
|
;; WARN: Return type mismatch basic vs string.
|
|
(defun editable-filter->string ((arg0 editable-filter) (arg1 basic))
|
|
(if (= (logand arg0 (editable-filter target)) (editable-filter target))
|
|
(format arg1 "target ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter city_vis)) (editable-filter city_vis))
|
|
(format arg1 "city_vis ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter water-command)) (editable-filter water-command))
|
|
(format arg1 "water-command ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter user-setting)) (editable-filter user-setting))
|
|
(format arg1 "user-setting ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter sample)) (editable-filter sample))
|
|
(format arg1 "sample ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter light)) (editable-filter light))
|
|
(format arg1 "light ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter part)) (editable-filter part))
|
|
(format arg1 "part ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter unknown)) (editable-filter unknown))
|
|
(format arg1 "unknown ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter entity)) (editable-filter entity))
|
|
(format arg1 "entity ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter data)) (editable-filter data))
|
|
(format arg1 "data ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter water)) (editable-filter water))
|
|
(format arg1 "water ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter cam-setting)) (editable-filter cam-setting))
|
|
(format arg1 "cam-setting ")
|
|
)
|
|
(if (= (logand (editable-filter selected) arg0) (editable-filter selected))
|
|
(format arg1 "selected ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter none)) (editable-filter none))
|
|
(format arg1 "none ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter camera)) (editable-filter camera))
|
|
(format arg1 "camera ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter load)) (editable-filter load))
|
|
(format arg1 "load ")
|
|
)
|
|
(if (= (logand arg0 (editable-filter sound)) (editable-filter sound))
|
|
(format arg1 "sound ")
|
|
)
|
|
(the-as string arg1)
|
|
)
|
|
|
|
;; definition of type editable-region
|
|
(deftype editable-region (basic)
|
|
((changed symbol :offset-assert 4)
|
|
(locked symbol :offset-assert 8)
|
|
(id uint64 :offset-assert 16)
|
|
(filter editable-filter :offset-assert 24)
|
|
(tree string :offset-assert 28)
|
|
(level string :offset-assert 32)
|
|
(on-enter string :offset-assert 36)
|
|
(on-inside string :offset-assert 40)
|
|
(on-exit string :offset-assert 44)
|
|
)
|
|
:method-count-assert 13
|
|
:size-assert #x30
|
|
:flag-assert #xd00000030
|
|
(:methods
|
|
(new (symbol type) _type_ 0)
|
|
(editable-region-method-9 (_type_ editable-array int int) none 9)
|
|
(editable-region-method-10 (_type_ int) symbol 10)
|
|
(editable-region-method-11 (_type_ vector int) none 11)
|
|
(editable-region-method-12 (_type_) editable-filter 12)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable-region
|
|
(defmethod inspect editable-region ((obj editable-region))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tchanged: ~A~%" (-> obj changed))
|
|
(format #t "~1Tlocked: ~A~%" (-> obj locked))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tfilter: ~D~%" (-> obj filter))
|
|
(format #t "~1Ttree: ~A~%" (-> obj tree))
|
|
(format #t "~1Tlevel: ~A~%" (-> obj level))
|
|
(format #t "~1Ton-enter: ~A~%" (-> obj on-enter))
|
|
(format #t "~1Ton-inside: ~A~%" (-> obj on-inside))
|
|
(format #t "~1Ton-exit: ~A~%" (-> obj on-exit))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type editable
|
|
(deftype editable (basic)
|
|
((flags editable-flag :offset-assert 4)
|
|
(name string :offset-assert 8)
|
|
(id uint32 :offset-assert 12)
|
|
(region editable-region :offset-assert 16)
|
|
(owner pair :offset-assert 20)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x18
|
|
:flag-assert #x1e00000018
|
|
(:methods
|
|
(get-color (_type_ int) rgba 9)
|
|
(editable-method-10 (_type_) none 10)
|
|
(editable-method-11 (_type_ vector) symbol 11)
|
|
(select-editable! (_type_ symbol) none 12)
|
|
(edit-get-distance (_type_ vector) float 13)
|
|
(edit-get-trans (_type_) vector 14)
|
|
(editable-method-15 (_type_ vector int) none 15)
|
|
(edit-coord! (_type_ vector editable-flag) none 16)
|
|
(editable-method-17 (_type_ vector) none 17)
|
|
(editable-method-18 (_type_ vector matrix) none 18)
|
|
(editable-method-19 (_type_ vector) none 19)
|
|
(editable-method-20 (_type_ vector vector vector vector) none 20)
|
|
(editable-method-21 (_type_ editable-region) none 21)
|
|
(editable-method-22 (_type_ editable-array int int) symbol 22)
|
|
(editable-method-23 (_type_) symbol 23)
|
|
(editable-method-24 (_type_) none 24)
|
|
(editable-method-25 (_type_ editable-array) none 25)
|
|
(editable-method-26 (_type_ editable editable-array) none 26)
|
|
(editable-method-27 (_type_ editable-array) editable 27)
|
|
(editable-method-28 (_type_ editable-filter) none 28)
|
|
(editable-method-29 (_type_ editable-filter) symbol 29)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable
|
|
(defmethod inspect editable ((obj editable))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-28)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tflags: #x~X : (editable-flag " (-> obj flags))
|
|
(let ((s5-0 (-> obj flags)))
|
|
(if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
|
|
(format #t "no-save ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
|
|
(format #t "top-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
|
|
(format #t "orient ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag z)) (editable-flag z))
|
|
(format #t "z ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag y)) (editable-flag y))
|
|
(format #t "y ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag x)) (editable-flag x))
|
|
(format #t "x ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
|
|
(format #t "changed ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
|
|
(format #t "no-plane-snap ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
|
|
(format #t "mark ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
|
|
(format #t "bot-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
|
|
(format #t "selected ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
|
|
(format #t "no-update ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Towner: ~A~%" (-> obj owner))
|
|
(label cfg-28)
|
|
obj
|
|
)
|
|
|
|
;; definition of type editable-array
|
|
(deftype editable-array (basic)
|
|
((allocated-length int32 :offset-assert 4)
|
|
(length int32 :offset-assert 8)
|
|
(region editable-region :offset-assert 12)
|
|
(backup-region editable-region :offset-assert 16)
|
|
(region-lock? symbol :offset-assert 20)
|
|
(move-lock? symbol :offset-assert 24)
|
|
(move-speed float :offset-assert 28)
|
|
(selection (array editable) :offset-assert 32)
|
|
(filter editable-filter 2 :offset-assert 36)
|
|
(target editable :offset-assert 44)
|
|
(target-mode uint32 :offset-assert 48)
|
|
(target-command basic :offset-assert 52)
|
|
(target-message string :offset-assert 56)
|
|
(edit-plane editable-plane :offset-assert 60)
|
|
(edit-plane-center vector :inline :offset-assert 64)
|
|
(edit-plane-normal vector :inline :offset-assert 80)
|
|
(level-offset vector :inline :offset-assert 96)
|
|
(level-info-id uint32 :offset-assert 112)
|
|
(level uint32 :offset-assert 116)
|
|
(edit-param0 float :offset-assert 120)
|
|
(data editable :dynamic :offset-assert 124)
|
|
)
|
|
:method-count-assert 18
|
|
:size-assert #x7c
|
|
:flag-assert #x120000007c
|
|
(:methods
|
|
(new (symbol type int) _type_ 0)
|
|
(editable-array-method-9 (_type_ editable-command editable-array) symbol :behavior editable-player 9)
|
|
(editable-array-method-10 (_type_ vector int) editable 10)
|
|
(editable-array-method-11 (_type_) int 11)
|
|
(editable-array-method-12 (_type_ editable-array) none 12)
|
|
(editable-array-method-13 (_type_ uint basic string) none 13)
|
|
(editable-array-method-14 (_type_ (function symbol) symbol) none 14)
|
|
(editable-array-method-15 (_type_ editable) none 15)
|
|
(editable-array-method-16 (_type_) none 16)
|
|
(editable-array-method-17 (_type_ vector vector) vector 17)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable-array
|
|
(defmethod inspect editable-array ((obj editable-array))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-7)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tallocated-length: ~D~%" (-> obj allocated-length))
|
|
(format #t "~1Tlength: ~D~%" (-> obj length))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Tbackup-region: ~A~%" (-> obj backup-region))
|
|
(format #t "~1Tregion-lock?: ~A~%" (-> obj region-lock?))
|
|
(format #t "~1Tmove-lock?: ~A~%" (-> obj move-lock?))
|
|
(format #t "~1Tmove-speed: ~f~%" (-> obj move-speed))
|
|
(format #t "~1Tselection: ~`basic`P~%" (-> obj selection))
|
|
(format #t "~1Tfilter[2] @ #x~X~%" (-> obj filter))
|
|
(format #t "~1Ttarget: ~A~%" (-> obj target))
|
|
(format #t "~1Ttarget-mode: ~D~%" (-> obj target-mode))
|
|
(format #t "~1Ttarget-command: ~D~%" (-> obj target-command))
|
|
(format #t "~1Ttarget-message: ~A~%" (-> obj target-message))
|
|
(format #t "~1Tedit-plane: ~A~%" (-> obj edit-plane))
|
|
(format #t "~1Tedit-plane-center: ~`vector`P~%" (-> obj edit-plane-center))
|
|
(format #t "~1Tedit-plane-normal: ~`vector`P~%" (-> obj edit-plane-normal))
|
|
(format #t "~1Tlevel-offset: ~`vector`P~%" (-> obj level-offset))
|
|
(format #t "~1Tlevel-info-id: ~D~%" (-> obj level-info-id))
|
|
(format #t "~1Tlevel: ~A~%" (-> obj level))
|
|
(format #t "~1Tedit-param0: ~f~%" (-> obj edit-param0))
|
|
(format #t "~1Tdata[0] @ #x~X~%" (-> obj data))
|
|
(dotimes (s5-0 (-> obj length))
|
|
(format #t "~T [~D]~1Tdata: ~A~%" s5-0 (-> obj data s5-0))
|
|
)
|
|
(label cfg-7)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type editable-array
|
|
(defmethod new editable-array ((allocation symbol) (type-to-make type) (arg0 int))
|
|
(let ((s5-0 (object-new allocation type-to-make (the-as int (+ (-> type-to-make size) (* arg0 4))))))
|
|
(set! (-> s5-0 allocated-length) arg0)
|
|
(set! (-> s5-0 length) 0)
|
|
(set! (-> s5-0 region) #f)
|
|
(set! (-> s5-0 backup-region) #f)
|
|
(set! (-> s5-0 region-lock?) #f)
|
|
(set! (-> s5-0 move-lock?) #f)
|
|
(set! (-> s5-0 target) #f)
|
|
(set! (-> s5-0 target-command) (the-as basic 0))
|
|
(set! (-> s5-0 target-message) #f)
|
|
(set! (-> s5-0 selection)
|
|
(the-as (array editable) ((method-of-type array new) allocation array editable arg0))
|
|
)
|
|
(set! (-> s5-0 edit-plane) #f)
|
|
(set! (-> s5-0 filter 0) (editable-filter
|
|
none
|
|
unknown
|
|
sound
|
|
part
|
|
user-setting
|
|
cam-setting
|
|
load
|
|
water-command
|
|
city_vis
|
|
sample
|
|
light
|
|
entity
|
|
)
|
|
)
|
|
(set! (-> s5-0 filter 1) (editable-filter camera target water data city_vis sample light entity selected))
|
|
(dotimes (v1-5 arg0)
|
|
(set! (-> s5-0 data v1-5) #f)
|
|
(set! (-> s5-0 selection v1-5) #f)
|
|
)
|
|
s5-0
|
|
)
|
|
)
|
|
|
|
;; definition of type editable-point
|
|
(deftype editable-point (editable)
|
|
((radius float :offset-assert 24)
|
|
(trans vector :inline :offset-assert 32)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x30
|
|
:flag-assert #x1e00000030
|
|
(:methods
|
|
(new (symbol type vector editable-region) _type_ 0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable-point
|
|
(defmethod inspect editable-point ((obj editable-point))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-28)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tflags: #x~X : (editable-flag " (-> obj flags))
|
|
(let ((s5-0 (-> obj flags)))
|
|
(if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
|
|
(format #t "no-save ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
|
|
(format #t "top-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
|
|
(format #t "orient ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag z)) (editable-flag z))
|
|
(format #t "z ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag y)) (editable-flag y))
|
|
(format #t "y ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag x)) (editable-flag x))
|
|
(format #t "x ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
|
|
(format #t "changed ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
|
|
(format #t "no-plane-snap ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
|
|
(format #t "mark ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
|
|
(format #t "bot-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
|
|
(format #t "selected ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
|
|
(format #t "no-update ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Towner: ~A~%" (-> obj owner))
|
|
(format #t "~1Tradius: (meters ~m)~%" (-> obj radius))
|
|
(format #t "~1Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(label cfg-28)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type editable-point
|
|
;; INFO: Used lq/sq
|
|
(defmethod new editable-point ((allocation symbol) (type-to-make type) (arg0 vector) (arg1 editable-region))
|
|
(let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> gp-0 region) #f)
|
|
(set! (-> gp-0 name) "undefined")
|
|
(editable-method-21 gp-0 (cond
|
|
(arg1
|
|
(empty)
|
|
arg1
|
|
)
|
|
(else
|
|
(new 'debug 'editable-region)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> gp-0 trans quad) (-> arg0 quad))
|
|
(set! (-> gp-0 radius) 2048.0)
|
|
(set! (-> gp-0 owner) '())
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition of type editable-sphere
|
|
(deftype editable-sphere (editable-point)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x30
|
|
:flag-assert #x1e00000030
|
|
(:methods
|
|
(new (symbol type vector float editable-region) _type_ 0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable-sphere
|
|
(defmethod inspect editable-sphere ((obj editable-sphere))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-28)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tflags: #x~X : (editable-flag " (-> obj flags))
|
|
(let ((s5-0 (-> obj flags)))
|
|
(if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
|
|
(format #t "no-save ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
|
|
(format #t "top-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
|
|
(format #t "orient ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag z)) (editable-flag z))
|
|
(format #t "z ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag y)) (editable-flag y))
|
|
(format #t "y ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag x)) (editable-flag x))
|
|
(format #t "x ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
|
|
(format #t "changed ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
|
|
(format #t "no-plane-snap ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
|
|
(format #t "mark ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
|
|
(format #t "bot-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
|
|
(format #t "selected ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
|
|
(format #t "no-update ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Towner: ~A~%" (-> obj owner))
|
|
(format #t "~1Tradius: (meters ~m)~%" (-> obj radius))
|
|
(format #t "~1Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(label cfg-28)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type editable-sphere
|
|
;; INFO: Used lq/sq
|
|
(defmethod new editable-sphere ((allocation symbol) (type-to-make type) (arg0 vector) (arg1 float) (arg2 editable-region))
|
|
(let ((s5-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> s5-0 region) #f)
|
|
(set! (-> s5-0 name) "undefined")
|
|
(editable-method-21 s5-0 (cond
|
|
(arg2
|
|
(empty)
|
|
arg2
|
|
)
|
|
(else
|
|
(new 'debug 'editable-region)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> s5-0 trans quad) (-> arg0 quad))
|
|
(set! (-> s5-0 radius) arg1)
|
|
(set! (-> s5-0 owner) '())
|
|
s5-0
|
|
)
|
|
)
|
|
|
|
;; definition of type editable-sample
|
|
(deftype editable-sample (editable-point)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x30
|
|
:flag-assert #x1e00000030
|
|
)
|
|
|
|
;; definition for method 3 of type editable-sample
|
|
(defmethod inspect editable-sample ((obj editable-sample))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-28)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tflags: #x~X : (editable-flag " (-> obj flags))
|
|
(let ((s5-0 (-> obj flags)))
|
|
(if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
|
|
(format #t "no-save ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
|
|
(format #t "top-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
|
|
(format #t "orient ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag z)) (editable-flag z))
|
|
(format #t "z ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag y)) (editable-flag y))
|
|
(format #t "y ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag x)) (editable-flag x))
|
|
(format #t "x ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
|
|
(format #t "changed ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
|
|
(format #t "no-plane-snap ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
|
|
(format #t "mark ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
|
|
(format #t "bot-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
|
|
(format #t "selected ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
|
|
(format #t "no-update ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Towner: ~A~%" (-> obj owner))
|
|
(format #t "~1Tradius: (meters ~m)~%" (-> obj radius))
|
|
(format #t "~1Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(label cfg-28)
|
|
obj
|
|
)
|
|
|
|
;; definition of type editable-light
|
|
(deftype editable-light (editable-sphere)
|
|
((direction vector :inline :offset-assert 48)
|
|
(color vector :inline :offset-assert 64)
|
|
(decay-start float :offset-assert 80)
|
|
(ambient-point-ratio float :offset-assert 84)
|
|
(brightness float :offset-assert 88)
|
|
)
|
|
:method-count-assert 30
|
|
:size-assert #x5c
|
|
:flag-assert #x1e0000005c
|
|
(:methods
|
|
(new (symbol type vector float editable-region) _type_ 0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable-light
|
|
(defmethod inspect editable-light ((obj editable-light))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-28)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tflags: #x~X : (editable-flag " (-> obj flags))
|
|
(let ((s5-0 (-> obj flags)))
|
|
(if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
|
|
(format #t "no-save ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
|
|
(format #t "top-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
|
|
(format #t "orient ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag z)) (editable-flag z))
|
|
(format #t "z ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag y)) (editable-flag y))
|
|
(format #t "y ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag x)) (editable-flag x))
|
|
(format #t "x ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
|
|
(format #t "changed ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
|
|
(format #t "no-plane-snap ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
|
|
(format #t "mark ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
|
|
(format #t "bot-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
|
|
(format #t "selected ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
|
|
(format #t "no-update ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Towner: ~A~%" (-> obj owner))
|
|
(format #t "~1Tradius: (meters ~m)~%" (-> obj radius))
|
|
(format #t "~1Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(format #t "~1Tdirection: ~`vector`P~%" (-> obj direction))
|
|
(format #t "~1Tcolor: ~`vector`P~%" (-> obj color))
|
|
(format #t "~1Tdecay-start: ~f~%" (-> obj decay-start))
|
|
(format #t "~1Tambient-point-ratio: ~f~%" (-> obj ambient-point-ratio))
|
|
(format #t "~1Tbrightness: ~f~%" (-> obj brightness))
|
|
(label cfg-28)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type editable-light
|
|
;; INFO: Used lq/sq
|
|
(defmethod new editable-light ((allocation symbol) (type-to-make type) (arg0 vector) (arg1 float) (arg2 editable-region))
|
|
(let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> gp-0 region) #f)
|
|
(editable-method-21 gp-0 (cond
|
|
(arg2
|
|
(empty)
|
|
arg2
|
|
)
|
|
(else
|
|
(new 'debug 'editable-region)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> gp-0 trans quad) (-> arg0 quad))
|
|
(set! (-> gp-0 radius) arg1)
|
|
(set! (-> gp-0 owner) '())
|
|
(let ((s5-1 (new 'debug 'string 32 (the-as string #f))))
|
|
(format s5-1 "undefined-~d" *editable-temp-id*)
|
|
(set! (-> gp-0 name) s5-1)
|
|
)
|
|
(set! *editable-temp-id* (+ *editable-temp-id* 1))
|
|
(set! (-> gp-0 decay-start) 0.5)
|
|
(set! (-> gp-0 ambient-point-ratio) 1.0)
|
|
(set! (-> gp-0 brightness) 1.0)
|
|
(set-vector! (-> gp-0 color) 1.0 1.0 1.0 -1.0)
|
|
(set-vector! (-> gp-0 direction) 0.0 0.0 0.0 0.0)
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition of type editable-entity
|
|
(deftype editable-entity (editable-point)
|
|
()
|
|
:method-count-assert 30
|
|
:size-assert #x30
|
|
:flag-assert #x1e00000030
|
|
)
|
|
|
|
;; definition for method 3 of type editable-entity
|
|
(defmethod inspect editable-entity ((obj editable-entity))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-28)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tflags: #x~X : (editable-flag " (-> obj flags))
|
|
(let ((s5-0 (-> obj flags)))
|
|
(if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
|
|
(format #t "no-save ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
|
|
(format #t "top-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
|
|
(format #t "orient ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag z)) (editable-flag z))
|
|
(format #t "z ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag y)) (editable-flag y))
|
|
(format #t "y ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag x)) (editable-flag x))
|
|
(format #t "x ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
|
|
(format #t "changed ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
|
|
(format #t "no-plane-snap ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
|
|
(format #t "mark ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
|
|
(format #t "bot-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
|
|
(format #t "selected ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
|
|
(format #t "no-update ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Towner: ~A~%" (-> obj owner))
|
|
(format #t "~1Tradius: (meters ~m)~%" (-> obj radius))
|
|
(format #t "~1Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(label cfg-28)
|
|
obj
|
|
)
|
|
|
|
;; definition of type editable-face
|
|
(deftype editable-face (editable)
|
|
((length int32 :offset-assert 24)
|
|
(normal vector :inline :offset-assert 32)
|
|
(center vector :inline :offset-assert 48)
|
|
(vertex editable-point 6 :offset-assert 64)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x58
|
|
:flag-assert #x2000000058
|
|
(:methods
|
|
(new (symbol type editable-region) _type_ 0)
|
|
(editable-face-method-30 (_type_ (inline-array vector)) int 30)
|
|
(editable-face-method-31 (_type_ vector) vector 31)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable-face
|
|
(defmethod inspect editable-face ((obj editable-face))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-31)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tflags: #x~X : (editable-flag " (-> obj flags))
|
|
(let ((s5-0 (-> obj flags)))
|
|
(if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
|
|
(format #t "no-save ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
|
|
(format #t "top-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
|
|
(format #t "orient ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag z)) (editable-flag z))
|
|
(format #t "z ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag y)) (editable-flag y))
|
|
(format #t "y ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag x)) (editable-flag x))
|
|
(format #t "x ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
|
|
(format #t "changed ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
|
|
(format #t "no-plane-snap ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
|
|
(format #t "mark ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
|
|
(format #t "bot-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
|
|
(format #t "selected ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
|
|
(format #t "no-update ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Towner: ~A~%" (-> obj owner))
|
|
(format #t "~1Tlength: ~D~%" (-> obj length))
|
|
(format #t "~1Tnormal: ~`vector`P~%" (-> obj normal))
|
|
(format #t "~1Tcenter: ~`vector`P~%" (-> obj center))
|
|
(format #t "~1Tvertex[6] @ #x~X~%" (-> obj vertex))
|
|
(dotimes (s5-1 (-> obj length))
|
|
(format #t "~T [~D]~1Tvertex: ~A~%" s5-1 (-> obj vertex s5-1))
|
|
)
|
|
(label cfg-31)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type editable-face
|
|
(defmethod new editable-face ((allocation symbol) (type-to-make type) (arg0 editable-region))
|
|
(let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> gp-0 region) #f)
|
|
(set! (-> gp-0 name) "undefined")
|
|
(editable-method-21 gp-0 (cond
|
|
(arg0
|
|
(empty)
|
|
arg0
|
|
)
|
|
(else
|
|
(new 'debug 'editable-region)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> gp-0 owner) '())
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition of type editable-plane
|
|
(deftype editable-plane (editable)
|
|
((length int32 :offset-assert 24)
|
|
(radius float :offset-assert 28)
|
|
(vertex editable-point 2 :offset-assert 32)
|
|
)
|
|
:method-count-assert 32
|
|
:size-assert #x28
|
|
:flag-assert #x2000000028
|
|
(:methods
|
|
(new (symbol type editable-region) _type_ 0)
|
|
(editable-plane-method-30 (_type_ matrix) int 30)
|
|
(editable-plane-method-31 (_type_ vector) vector 31)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable-plane
|
|
(defmethod inspect editable-plane ((obj editable-plane))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-31)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tflags: #x~X : (editable-flag " (-> obj flags))
|
|
(let ((s5-0 (-> obj flags)))
|
|
(if (= (logand s5-0 (editable-flag no-save)) (editable-flag no-save))
|
|
(format #t "no-save ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag top-set)) (editable-flag top-set))
|
|
(format #t "top-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag orient)) (editable-flag orient))
|
|
(format #t "orient ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag z)) (editable-flag z))
|
|
(format #t "z ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag y)) (editable-flag y))
|
|
(format #t "y ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag x)) (editable-flag x))
|
|
(format #t "x ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag changed)) (editable-flag changed))
|
|
(format #t "changed ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-plane-snap)) (editable-flag no-plane-snap))
|
|
(format #t "no-plane-snap ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag mark)) (editable-flag mark))
|
|
(format #t "mark ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag bot-set)) (editable-flag bot-set))
|
|
(format #t "bot-set ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag selected)) (editable-flag selected))
|
|
(format #t "selected ")
|
|
)
|
|
(if (= (logand s5-0 (editable-flag no-update)) (editable-flag no-update))
|
|
(format #t "no-update ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tname: ~A~%" (-> obj name))
|
|
(format #t "~1Tid: ~D~%" (-> obj id))
|
|
(format #t "~1Tregion: ~A~%" (-> obj region))
|
|
(format #t "~1Towner: ~A~%" (-> obj owner))
|
|
(format #t "~1Tlength: ~D~%" (-> obj length))
|
|
(format #t "~1Tradius: (meters ~m)~%" (-> obj radius))
|
|
(format #t "~1Tvertex[2] @ #x~X~%" (-> obj vertex))
|
|
(dotimes (s5-1 (-> obj length))
|
|
(format #t "~T [~D]~1Tvertex: ~A~%" s5-1 (-> obj vertex s5-1))
|
|
)
|
|
(label cfg-31)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type editable-plane
|
|
(defmethod new editable-plane ((allocation symbol) (type-to-make type) (arg0 editable-region))
|
|
(let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> gp-0 region) #f)
|
|
(set! (-> gp-0 name) "undefined")
|
|
(editable-method-21 gp-0 (cond
|
|
(arg0
|
|
(empty)
|
|
arg0
|
|
)
|
|
(else
|
|
(new 'debug 'editable-region)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> gp-0 owner) '())
|
|
(set! (-> gp-0 radius) 20480.0)
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition of type editable-player
|
|
(deftype editable-player (process-drawable)
|
|
((current editable-array :offset-assert 200)
|
|
(select-command function :offset-assert 204)
|
|
(move-command function :offset-assert 208)
|
|
(extra-command function :offset-assert 212)
|
|
(left-handed basic :offset-assert 216)
|
|
(light-names basic :offset-assert 220)
|
|
(external-cam-mode symbol :offset-assert 224)
|
|
(command function 6 :offset-assert 228)
|
|
(close-menu-time time-frame :offset-assert 256)
|
|
)
|
|
:heap-base #x90
|
|
:method-count-assert 22
|
|
:size-assert #x108
|
|
:flag-assert #x1600900108
|
|
(:methods
|
|
(idle () _type_ :state 20)
|
|
(editable-player-method-21 (_type_) none 21)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type editable-player
|
|
(defmethod inspect editable-player ((obj editable-player))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~2Tcurrent: ~A~%" (-> obj current))
|
|
(format #t "~2Tselect-command: ~D~%" (-> obj select-command))
|
|
(format #t "~2Tmove-command: ~D~%" (-> obj move-command))
|
|
(format #t "~2Textra-command: ~D~%" (-> obj extra-command))
|
|
(format #t "~2Tleft-handed: ~A~%" (-> obj left-handed))
|
|
(format #t "~2Tlight-names: ~A~%" (-> obj light-names))
|
|
(format #t "~2Texternal-cam-mode: ~A~%" (-> obj external-cam-mode))
|
|
(format #t "~2Tcommand[6] @ #x~X~%" (-> obj command))
|
|
(format #t "~2Tclose-menu-time: ~D~%" (-> obj close-menu-time))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type editable-work
|
|
(deftype editable-work (basic)
|
|
((num-found int16 :offset-assert 4)
|
|
(last-found int16 :offset-assert 6)
|
|
(last-x float :offset-assert 8)
|
|
(last-y float :offset-assert 12)
|
|
(found editable 256 :offset-assert 16)
|
|
(dists uint32 256 :offset-assert 1040)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x810
|
|
:flag-assert #x900000810
|
|
)
|
|
|
|
;; definition for method 3 of type editable-work
|
|
(defmethod inspect editable-work ((obj editable-work))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~1Tnum-found: ~D~%" (-> obj num-found))
|
|
(format #t "~1Tlast-found: ~D~%" (-> obj last-found))
|
|
(format #t "~1Tlast-x: ~f~%" (-> obj last-x))
|
|
(format #t "~1Tlast-y: ~f~%" (-> obj last-y))
|
|
(format #t "~1Tfound[256] @ #x~X~%" (-> obj found))
|
|
(format #t "~1Tdists[256] @ #x~X~%" (-> obj dists))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition for symbol *editable-work*, type editable-work
|
|
(define *editable-work* (new 'global 'editable-work))
|
|
|
|
;; definition for symbol *editable*, type (pointer editable-player)
|
|
(define *editable* (the-as (pointer editable-player) #f))
|
|
|
|
;; failed to figure out what this is:
|
|
0
|