;;-*-Lisp-*-
(in-package goal)

;; definition of type load-dir
(deftype load-dir (basic)
  ((lev          level           :offset-assert   4)
   (string-array (array string)  :offset-assert   8)
   (data-array   (array basic)   :offset-assert  12)
   )
  :method-count-assert 11
  :size-assert         #x10
  :flag-assert         #xb00000010
  (:methods
    (new (symbol type int level) _type_ 0)
    (load-to-heap-by-name (_type_ string symbol kheap int) art-group 9)
    (set-loaded-art (_type_ art-group) art-group 10)
    )
  )

;; definition of type load-dir-art-group
(deftype load-dir-art-group (load-dir)
  ((art-group-array (array art-group)  :offset  12)
   )
  :method-count-assert 11
  :size-assert         #x10
  :flag-assert         #xb00000010
  (:methods
    (new (symbol type int level) _type_ 0)
    )
  )

;; definition for method 0 of type load-dir
(defmethod new load-dir ((allocation symbol) (type-to-make type) (arg0 int) (arg1 level))
  (let ((s4-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> s4-0 lev) arg1)
    (set! (-> s4-0 string-array)
          (the-as (array string) ((method-of-type array new) allocation array string arg0))
          )
    (set! (-> s4-0 string-array length) 0)
    (set! (-> s4-0 data-array) (the-as (array basic) ((method-of-type array new) allocation array basic arg0)))
    (set! (-> s4-0 data-array length) 0)
    s4-0
    )
  )

;; definition for method 0 of type load-dir-art-group
;; WARN: Return type mismatch load-dir vs load-dir-art-group.
(defmethod new load-dir-art-group ((allocation symbol) (type-to-make type) (arg0 int) (arg1 level))
  (let ((v0-0 ((method-of-type load-dir new) allocation type-to-make arg0 arg1)))
    (set! (-> v0-0 data-array content-type) art-group)
    (the-as load-dir-art-group v0-0)
    )
  )

;; definition of type external-art-buffer
(deftype external-art-buffer (basic)
  ((index                      int32                                         :offset-assert   4)
   (other                      external-art-buffer                           :offset-assert   8)
   (status                     symbol                                        :offset-assert  12)
   (locked?                    symbol                                        :offset-assert  16)
   (login?                     symbol                                        :offset-assert  20)
   (frame-lock                 symbol                                        :offset-assert  24)
   (init-heap                  (function external-art-buffer object)         :offset-assert  28)
   (heap                       kheap                                 :inline :offset-assert  32)
   (pending-load-file          string                                        :offset-assert  48)
   (pending-load-file-part     int32                                         :offset-assert  52)
   (pending-load-file-owner    handle                                        :offset-assert  56)
   (pending-load-file-priority float                                         :offset-assert  64)
   (load-file                  string                                        :offset-assert  68)
   (load-file-part             int32                                         :offset-assert  72)
   (load-file-owner            handle                                        :offset-assert  80)
   (load-file-priority         float                                         :offset-assert  88)
   (buf                        pointer                                       :offset-assert  92)
   (len                        int32                                         :offset-assert  96)
   (art-group                  art-group                                     :offset-assert 100)
   (art-data                   uint32                                        :offset        100)
   )
  :method-count-assert 16
  :size-assert         #x68
  :flag-assert         #x1000000068
  (:methods
    (new (symbol type int function symbol) _type_ 0)
    (set-pending-file (_type_ string int handle float) int 9)
    (update (_type_) int 10)
    (inactive? (_type_) symbol 11)
    (file-status (_type_ string int) symbol 12)
    (link-file (_type_ art-group) art-group 13)
    (unlink-file (_type_ art-group) int 14)
    (unlock! (_type_) int 15)
    )
  )

;; definition for method 3 of type external-art-buffer
(defmethod inspect external-art-buffer ((obj external-art-buffer))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tindex: ~D~%" (-> obj index))
  (format #t "~1Tother: ~A~%" (-> obj other))
  (format #t "~1Tstatus: ~A~%" (-> obj status))
  (format #t "~1Tlocked?: ~A~%" (-> obj locked?))
  (format #t "~1Tlogin?: ~A~%" (-> obj login?))
  (format #t "~1Tframe-lock: ~A~%" (-> obj frame-lock))
  (format #t "~1Tinit-heap: ~A~%" (-> obj init-heap))
  (format #t "~1Theap: #<kheap @ #x~X>~%" (-> obj heap))
  (format #t "~1Tpending-load-file: ~A~%" (-> obj pending-load-file))
  (format #t "~1Tpending-load-file-part: ~D~%" (-> obj pending-load-file-part))
  (format #t "~1Tpending-load-file-owner: ~D~%" (-> obj pending-load-file-owner))
  (format #t "~1Tpending-load-file-priority: ~f~%" (-> obj pending-load-file-priority))
  (format #t "~1Tload-file: ~A~%" (-> obj load-file))
  (format #t "~1Tload-file-part: ~D~%" (-> obj load-file-part))
  (format #t "~1Tload-file-owner: ~D~%" (-> obj load-file-owner))
  (format #t "~1Tload-file-priority: ~f~%" (-> obj load-file-priority))
  (format #t "~1Tbuf: #x~X~%" (-> obj buf))
  (format #t "~1Tlen: ~D~%" (-> obj len))
  (format #t "~1Tart-group: ~A~%" (-> obj art-group))
  (format #t "~1Tart-data: #x~X~%" (-> obj art-group))
  (label cfg-4)
  obj
  )

;; definition for method 0 of type external-art-buffer
(defmethod new external-art-buffer ((allocation symbol) (type-to-make type) (arg0 int) (arg1 function) (arg2 symbol))
  (let ((v0-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> v0-0 index) arg0)
    (set! (-> v0-0 init-heap) (the-as (function external-art-buffer object) arg1))
    (set! (-> v0-0 login?) arg2)
    (set! (-> v0-0 load-file) #f)
    (set! (-> v0-0 load-file-part) -1)
    (set! (-> v0-0 load-file-owner) (the-as handle #f))
    (set! (-> v0-0 load-file-priority) 100000000.0)
    (set! (-> v0-0 pending-load-file) #f)
    (set! (-> v0-0 pending-load-file-part) -1)
    (set! (-> v0-0 pending-load-file-owner) (the-as handle #f))
    (set! (-> v0-0 pending-load-file-priority) 100000000.0)
    (set! (-> v0-0 art-group) #f)
    (set! (-> v0-0 status) 'initialize)
    (set! (-> v0-0 locked?) #f)
    (set! (-> v0-0 other) #f)
    v0-0
    )
  )

;; definition of type spool-anim
(deftype spool-anim (basic)
  ((name         string               :offset         16)
   (anim-name    basic                :offset-assert  20)
   (buffer       external-art-buffer  :offset         20)
   (parts        int32                :offset-assert  24)
   (hint-id      int32                :offset         24)
   (priority     float                :offset-assert  28)
   (owner        handle               :offset-assert  32)
   (command-list pair                 :offset-assert  40)
   )
  :method-count-assert 9
  :size-assert         #x2c
  :flag-assert         #x90000002c
  )

;; definition for method 3 of type spool-anim
(defmethod inspect spool-anim ((obj spool-anim))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tname: ~A~%" (-> obj name))
  (format #t "~1Tanim-name: ~A~%" (-> obj buffer))
  (format #t "~1Tparts: ~D~%" (-> obj parts))
  (format #t "~1Thint-id: ~D~%" (-> obj parts))
  (format #t "~1Tpriority: ~f~%" (-> obj priority))
  (format #t "~1Towner: ~D~%" (-> obj owner))
  (format #t "~1Tcommand-list: ~A~%" (-> obj command-list))
  (label cfg-4)
  obj
  )

;; definition of type external-art-control
(deftype external-art-control (basic)
  ((buffer                   external-art-buffer 2         :offset-assert   4)
   (rec                      spool-anim          3 :inline :offset-assert  16)
   (spool-lock               handle                        :offset-assert 160)
   (reserve-buffer           external-art-buffer           :offset-assert 168)
   (reserve-buffer-count     int16                         :offset-assert 172)
   (dma-reserve-buffer-count int16                         :offset-assert 174)
   (active-stream            string                        :offset-assert 176)
   (queue-stream             (array spool-anim)            :offset-assert 180)
   (frame-mask               uint32                        :offset-assert 184)
   (dma-reserve-heap         kheap               :inline   :offset-assert 192)
   )
  :method-count-assert 16
  :size-assert         #xd0
  :flag-assert         #x10000000d0
  (:methods
    (new (symbol type) _type_ 0)
    (update (_type_ symbol) int 9)
    (clear-rec (_type_) int 10)
    (spool-push (_type_ string int process float) int 11)
    (file-status (_type_ string int) symbol 12)
    (reserve-alloc (_type_) kheap 13)
    (reserve-free (_type_ kheap) int 14)
    (none-reserved? (_type_) symbol 15)
    )
  )

;; definition for method 3 of type external-art-control
(defmethod inspect external-art-control ((obj external-art-control))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tbuffer[2] @ #x~X~%" (-> obj buffer))
  (format #t "~1Trec[3] @ #x~X~%" (-> obj rec))
  (format #t "~1Tspool-lock: ~D~%" (-> obj spool-lock))
  (format #t "~1Treserve-buffer: ~A~%" (-> obj reserve-buffer))
  (format #t "~1Treserve-buffer-count: ~D~%" (-> obj reserve-buffer-count))
  (format #t "~1Tdma-reserve-buffer-count: ~D~%" (-> obj dma-reserve-buffer-count))
  (format #t "~1Tactive-stream: ~A~%" (-> obj active-stream))
  (format #t "~1Tqueue-stream: ~A~%" (-> obj queue-stream))
  (format #t "~1Tframe-mask: ~D~%" (-> obj frame-mask))
  (format #t "~1Tdma-reserve-heap: #<kheap @ #x~X>~%" (-> obj dma-reserve-heap))
  (label cfg-4)
  obj
  )

;; definition for method 0 of type external-art-control
(defmethod new external-art-control ((allocation symbol) (type-to-make type))
  (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (dotimes (s4-0 2)
      (set! (-> gp-0 buffer s4-0)
            ((method-of-type external-art-buffer new) allocation external-art-buffer s4-0 external-art-buffer-init #t)
            )
      )
    (set! (-> gp-0 buffer 0 other) (-> gp-0 buffer 1))
    (set! (-> gp-0 buffer 1 other) (-> gp-0 buffer 0))
    (dotimes (v1-9 3)
      (set! (-> gp-0 rec v1-9 name) #f)
      (set! (-> gp-0 rec v1-9 priority) 100000000.0)
      (set! (-> gp-0 rec v1-9 owner) (the-as handle #f))
      )
    (set! (-> gp-0 spool-lock) (the-as handle #f))
    (set! (-> gp-0 reserve-buffer) #f)
    (set! (-> gp-0 active-stream) #f)
    (set! (-> gp-0 queue-stream) (new 'global 'boxed-array spool-anim 4))
    (dotimes (s5-1 (-> gp-0 queue-stream allocated-length))
      (set! (-> gp-0 queue-stream s5-1) (new 'global 'spool-anim))
      )
    (set! (-> gp-0 queue-stream length) 0)
    gp-0
    )
  )

;; definition of type subtitle-range
(deftype subtitle-range (basic)
  ((start-frame float    :offset-assert   4)
   (end-frame   float    :offset-assert   8)
   (message     object 8 :offset-assert  12)
   )
  :method-count-assert 9
  :size-assert         #x2c
  :flag-assert         #x90000002c
  )

;; definition for method 3 of type subtitle-range
(defmethod inspect subtitle-range ((obj subtitle-range))
  (when (not obj)
    (set! obj obj)
    (goto cfg-7)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tstart-frame: ~f~%" (-> obj start-frame))
  (format #t "~1Tend-frame: ~f~%" (-> obj end-frame))
  (format #t "~1Tmessage[8] @ #x~X~%" (-> obj message))
  (dotimes (s5-0 8)
    (format #t "~T  [~D]~1Tmessage: ~`object`P~%" s5-0 (-> obj message s5-0))
    )
  (label cfg-7)
  obj
  )

;; definition of type subtitle-image
(deftype subtitle-image (basic)
  ((width   uint16          :offset-assert   4)
   (height  uint16          :offset-assert   6)
   (palette rgba   16       :offset         16)
   (data    uint8  :dynamic :offset-assert  80)
   )
  :method-count-assert 9
  :size-assert         #x50
  :flag-assert         #x900000050
  )

;; definition for method 3 of type subtitle-image
(defmethod inspect subtitle-image ((obj subtitle-image))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Twidth: ~D~%" (-> obj width))
  (format #t "~1Theight: ~D~%" (-> obj height))
  (format #t "~1Tpalette[16] @ #x~X~%" (-> obj palette))
  (format #t "~1Tdata[0] @ #x~X~%" (-> obj data))
  (label cfg-4)
  obj
  )

;; failed to figure out what this is:
0