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

#|

  Extra debug menus for PC port.

|#
(declare-file (debug))

(defmacro new-dm-func (text var func)
  `(new 'debug 'debug-menu-item-function ,text ,var (the-as (function int object) ,func))
  )
(defmacro new-dm-flag (text var func)
  `(new 'debug 'debug-menu-item-flag ,text ,var (the-as (function int debug-menu-msg object) ,func))
  )
(defmacro new-dm-bool (text sym func)
  `(new-dm-flag ,text (quote ,sym) ,func)
  )
(defmacro new-dm-submenu (text menu)
  `(new 'debug 'debug-menu-item-submenu ,text ,menu)
  )
(defmacro new-dm-var-float (text var func inc min max)
  `(debug-menu-item-var-make-float (new 'debug 'debug-menu-item-var ,text ,var (* 8 20))
              (the-as (function int debug-menu-msg float float float) ,func)
              ,inc #t ,min ,max 1)
  )

(defun dm-want-level-toggle-pick-func ((arg0 pair) (arg1 debug-menu-msg))
  (let* ((levname (the-as symbol (car arg0)))
        (info (the-as level-load-info (-> levname value)))
        (idx (the int (cdr arg0)))
        (the-level (level-get *level* (-> info name)))
        )
    (if (and the-level (!= the-level (-> *level* level idx)))
      (return 'invalid)
      )
    (if (= arg1 (debug-menu-msg press))
        (load-state-want-levels
            (if (= idx 0) (-> info name) (-> *level* level 0 name))
            (if (= idx 1) (-> info name) (-> *level* level 1 name))
            )
        )
    (eq? (-> *level* level idx name) (-> info name))
    )
  )

(defun dm-display-level-toggle-pick-func ((arg0 symbol) (arg1 debug-menu-msg))
  (let ((the-level (level-get *level* arg0)))
    (if (not the-level)
      (return 'invalid)
      )
    (if (= arg1 (debug-menu-msg press))
        (when the-level
          (load-state-want-display-level arg0
              (if (-> the-level display?) #f 'display)
              )
          )
        )
    (and the-level (-> the-level display?))
    )
  )

(defun debug-menu-make-load-want-menu ((ctx debug-menu-context) (lev-idx int))

  (let ((want-menu (new 'debug 'debug-menu ctx "Level want menu")))

      (let ((iter *level-load-list*))
          (while (not (or (null? iter) (null? (cdr iter)) (null? (cddr iter))))
            (debug-menu-append-item want-menu (new-dm-flag (symbol->string (the-as symbol (car iter))) (dcons (car iter) lev-idx) dm-want-level-toggle-pick-func))

            (set! iter (cdr iter))
            )
          )

      (new-dm-submenu (new 'debug 'string 0 (string-format "Want ~D" lev-idx)) want-menu)
      )
  )

(defun debug-menu-make-load-display-menu ((ctx debug-menu-context))

  (let ((display-menu (new 'debug 'debug-menu ctx "Level display menu")))

      (let ((iter *level-load-list*))
          (while (not (or (null? iter) (null? (cdr iter)) (null? (cddr iter))))
            (debug-menu-append-item display-menu (new-dm-flag (symbol->string (the-as symbol (car iter))) (car iter) dm-display-level-toggle-pick-func))

            (set! iter (cdr iter))
            )
          )

      (new-dm-submenu "Display" display-menu)
      )
  )

(defun debug-menu-make-load-teleport-menu ((ctx debug-menu-context))

  (let ((teleport-menu (new 'debug 'debug-menu ctx "Camera teleport menu")))

      (let ((iter *level-load-list*))
          (while (not (or (null? iter) (null? (cdr iter)) (null? (cddr iter))))
            (debug-menu-append-item teleport-menu
                (new-dm-func (symbol->string (the-as symbol (car iter)))
                                 (-> (the-as symbol (car iter)) value)
                                 (lambda ((info level-load-info))
                                  (let ((tf (new 'stack-no-clear 'transformq)))
                                    (set! (-> tf trans x) (-> info bsphere x))
                                    (set! (-> tf trans y) (-> info bsphere y))
                                    (set! (-> tf trans z) (-> info bsphere z))
                                    (quaternion-identity! (-> tf quat))
                                    (vector-identity! (-> tf scale))
                                    (send-event *camera* 'teleport-to-transformq tf)
                                    )
                                  )
                                 ))

            (set! iter (cdr iter))
            )
          )

      (new-dm-submenu "Camera teleport" teleport-menu)
      )
  )

(defun debug-menu-make-load-menu ((ctx debug-menu-context))
  (let ((load-menu (new 'debug 'debug-menu ctx "Load menu")))
      (debug-menu-append-item load-menu (new-dm-bool "Level Border" *display-level-border* dm-boolean-toggle-pick-func))
      (debug-menu-append-item load-menu (debug-menu-make-from-template ctx '(flag
               "border-mode"
               #f
               ,(lambda ((arg0 int) (arg1 debug-menu-msg))
                 (if (= arg1 (debug-menu-msg press))
                     (set! (-> *setting-control* default border-mode) (not (-> *setting-control* default border-mode)))
                     )
                 (-> *setting-control* default border-mode)
                 )
               )))

      (debug-menu-append-item load-menu (debug-menu-make-load-want-menu ctx 0)) ;; Want 0
      (debug-menu-append-item load-menu (debug-menu-make-load-want-menu ctx 1)) ;; Want 1
      (debug-menu-append-item load-menu (debug-menu-make-load-display-menu ctx)) ;; Display
      (debug-menu-append-item load-menu (debug-menu-make-load-teleport-menu ctx)) ;; Camera teleport

      (new-dm-submenu "Load" load-menu)
      )
  )

(define *part-pick-menu* (the-as debug-menu #f))
(define *spawn-part-test* #t)

(defun dm-part-pick-func ((id int) (msg debug-menu-msg))
  (if (zero? (-> *part-group-id-table* id))
    (return 'invalid))
  (when (= msg (debug-menu-msg press))
    (set! *part-tester-id* id)
    (if *spawn-part-test*
        (start-part)
        )
    )
  (= *part-tester-id* id)
  )

(defun build-particles-list ()
  (debug-menu-remove-all-items *part-pick-menu*)
  (dotimes (i (-> *part-group-id-table* length))
    (let ((part (-> *part-group-id-table* i)))
      (when (and (nonzero? part))
        (debug-menu-append-item *part-pick-menu* (new-dm-flag (-> part name) i dm-part-pick-func))
        )
      )
    )
  (set! (-> *part-pick-menu* items) (sort (-> *part-pick-menu* items) debug-menu-node<?))
  )

(defun debug-menu-make-part-menu ((ctx debug-menu-context))
  (let ((part-menu (new 'debug 'debug-menu ctx "Particles menu")))
      (let ((pick-menu (new 'debug 'debug-menu ctx "Particle group pick menu")))
        (set! *part-pick-menu* pick-menu)
        (debug-menu-append-item part-menu (new-dm-submenu "Pick Particle group" pick-menu))
        )
      (debug-menu-append-item part-menu (new-dm-func "Refresh" #f build-particles-list))
      (debug-menu-append-item part-menu (new-dm-bool "Spawn part tester" *spawn-part-test* dm-boolean-toggle-pick-func))

      (new-dm-submenu "Particles" part-menu)
      )
  )

(define *entity-pick-menu* (the-as debug-menu #f))

(defun dm-entity-pick-func ((e entity) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (if (= (-> *entity-debug-inspect* entity) e)
      (set-entity! *entity-debug-inspect* (the entity #f))
      (set-entity! *entity-debug-inspect* e))
    )
  (= (-> *entity-debug-inspect* entity) e)
  )

(defun build-entity-list ()
  "Fill the entity pick menu"
  ;; clear old list
  (debug-menu-remove-all-items *entity-pick-menu*)
  ;; go through active levels
  (dotimes (s5-0 (-> *level* length))
    (let ((s4-0 (-> *level* level s5-0)))
      (when (= (-> s4-0 status) 'active)
        ;; actor entities
        (let ((s3-0 (-> s4-0 bsp actors)))
          (when (nonzero? s3-0)
            (dotimes (s2-0 (-> s3-0 length))
              (let ((s1-0 (-> s3-0 data s2-0 actor)))
                (debug-menu-append-item *entity-pick-menu* (new-dm-flag (res-lump-struct s1-0 'name string) s1-0 dm-entity-pick-func))
                )
              )
            )
          )
        ;; ambients entities
        (let ((s3-1 (-> s4-0 bsp ambients)))
          (when (nonzero? s3-1)
            (dotimes (s2-1 (-> s3-1 length))
              (let ((s1-1 (-> s3-1 data s2-1 ambient)))
                (debug-menu-append-item *entity-pick-menu* (new-dm-flag (res-lump-struct s1-1 'name string) s1-1 dm-entity-pick-func))
                )
              )
            )
          )
        ;; camera entities
        (let ((s4-1 (-> s4-0 bsp cameras)))
          (when (nonzero? s4-1)
            (dotimes (s3-2 (-> s4-1 length))
              (let ((s2-2 (-> s4-1 s3-2)))
                (debug-menu-append-item *entity-pick-menu* (new-dm-flag (res-lump-struct s2-2 'name string) s2-2 dm-entity-pick-func))
                )
              )
            )
          )
        )
      )
    )
  (set! (-> *entity-pick-menu* items) (sort (-> *entity-pick-menu* items) debug-menu-node<?))
  )

(defun dm-display-entities-pick-func ((arg0 symbol))
  (debug-print-entities *level* arg0 (the-as type #f))
  )

(defun debug-menu-make-entity-menu ((ctx debug-menu-context))
  (let ((entity-menu (new 'debug 'debug-menu ctx "Entity menu")))
      (let ((pick-menu (new 'debug 'debug-menu ctx "Pick entity menu")))
        (set! *entity-pick-menu* pick-menu)
        (debug-menu-append-item entity-menu (new-dm-submenu "Pick Entity" pick-menu))
        )
      (debug-menu-append-item entity-menu (new-dm-func "Refresh" #f build-entity-list))
      (debug-menu-append-item entity-menu (new-dm-func "Go to entity" #f
                                              (lambda ()
                                                (unless (-> *entity-debug-inspect* entity) (return #f))
                                                (let ((tf (new 'stack 'transformq)))
                                                  (vector-copy! (-> tf trans) (-> *entity-debug-inspect* entity trans))
                                                  (quaternion-identity! (-> tf quat))
                                                  (vector-identity! (-> tf scale))
                                                  (send-event *camera* 'teleport-to-transformq tf)
                                                  ))))
      (debug-menu-append-item entity-menu (new-dm-func "Print entity info" #t dm-display-entities-pick-func))
      (debug-menu-append-item entity-menu (new-dm-func "Print entity info (ag)" 'art-group dm-display-entities-pick-func))
      (debug-menu-append-item entity-menu (new-dm-func "Print entity info (meters)" 'entity-meters dm-display-entities-pick-func))
      (debug-menu-append-item entity-menu (new-dm-func "Print entity info (perm)" 'entity-perm dm-display-entities-pick-func))

      (new-dm-submenu "Entity" entity-menu)
      )
  )

(defmacro dm-lambda-boolean-flag (val)
  "helper macro for making boolean buttons that don't just access symbols directly"
  `,(lambda (arg (msg debug-menu-msg))
                            (if (= msg (debug-menu-msg press))
                                (not! ,val)
                                )
                            ,val)
  )

(defmacro dm-lambda-int-var (val)
  "helper macro for making int buttons"
  `,(lambda (arg (msg debug-menu-msg) (newval int))
    (cond
      ((= msg (debug-menu-msg press))
       (set! ,val newval)
       )
      (else
        ,val
        )
      ))
  )

(defmacro dm-lambda-float-var (val)
  "helper macro for making float buttons"
  `(lambda (arg (msg debug-menu-msg) (newval float))
    (cond
      ((= msg (debug-menu-msg press))
       (set! ,val newval)
       )
      (else
        ,val
        )
      ))
  )

(defmacro dm-lambda-meters-var (val)
  "helper macro for making meters buttons"
  `,(lambda (arg (msg debug-menu-msg) (newval float))
    (cond
      ((= msg (debug-menu-msg press))
       (set! ,val (meters newval))
       )
      (else
        (* (1/ METER_LENGTH) ,val)
        )
      ))
  )

(defun dm-toggle-collision-pick-func ((arg symbol) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (cond
      ((-> arg value)
       (false! (-> arg value))
       (logior! *vu1-enable-user-menu* (vu1-renderer-mask tfrag trans-tfrag tie tie-near))
       (true! *generic-tie*)
       )
      (else
       (true! (-> arg value))
       (logclear! *vu1-enable-user-menu* (vu1-renderer-mask tfrag trans-tfrag tie tie-near))
       (false! *generic-tie*)
       )
      )
    )
  (-> arg value)
  )

(defun dm-collision-mode-pick-func ((arg pc-collision-mode) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (set! *collision-mode* arg)
    )
  (= *collision-mode* arg)
  )

(defun dm-collision-filter-mode-pick-func ((arg int) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (pc-set-collision-mask (pc-collision-mode mode) arg (not (pc-get-collision-mask (pc-collision-mode mode) arg)))
    )
  (pc-get-collision-mask (pc-collision-mode mode) arg)
  )

(defun dm-collision-filter-event-pick-func ((arg int) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (pc-set-collision-mask (pc-collision-mode event) arg (not (pc-get-collision-mask (pc-collision-mode event) arg)))
    )
  (pc-get-collision-mask (pc-collision-mode event) arg)
  )

(defun dm-collision-filter-material-pick-func ((arg int) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (pc-set-collision-mask (pc-collision-mode material) arg (not (pc-get-collision-mask (pc-collision-mode material) arg)))
    )
  (pc-get-collision-mask (pc-collision-mode material) arg)
  )

(defun dm-collision-filter-skip-pick-func ((arg int) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (pc-set-collision-mask (pc-collision-mode skip) arg (not (pc-get-collision-mask (pc-collision-mode skip) arg)))
    )
  (pc-get-collision-mask (pc-collision-mode skip) arg)
  )

(defun debug-menu-make-collision-renderer-menu ((ctx debug-menu-context))
  (let ((menu (new 'debug 'debug-menu ctx "Collision renderer menu")))
      ;; master toggle
      (debug-menu-append-item menu (new-dm-bool "Enable" *collision-renderer* dm-toggle-collision-pick-func))
      (debug-menu-append-item menu (new-dm-bool "Wireframe" *collision-wireframe* dm-boolean-toggle-pick-func))
      (debug-menu-append-item menu (new-dm-submenu "Mode"
          (let ((mode-menu (new 'debug 'debug-menu ctx "Collision renderer mode menu")))
              (doenum (name val pc-collision-mode)
                  (debug-menu-append-item mode-menu (new-dm-flag name val dm-collision-mode-pick-func))
                  )
              mode-menu)))
      (debug-menu-append-item menu (new-dm-submenu "Filter mode"
          (let ((filter-menu (new 'debug 'debug-menu ctx "Collision renderer filter mode menu")))
              (doenum (name val pat-mode)
                  (debug-menu-append-item filter-menu (new-dm-flag name val dm-collision-filter-mode-pick-func))
                  )
              filter-menu)))
      (debug-menu-append-item menu (new-dm-submenu "Filter event"
          (let ((filter-menu (new 'debug 'debug-menu ctx "Collision renderer filter event menu")))
              (doenum (name val pat-event)
                  (debug-menu-append-item filter-menu (new-dm-flag name val dm-collision-filter-event-pick-func))
                  )
              filter-menu)))
      (debug-menu-append-item menu (new-dm-submenu "Filter material"
          (let ((filter-menu (new 'debug 'debug-menu ctx "Collision renderer filter material menu")))
              (doenum (name val pat-material)
                  (debug-menu-append-item filter-menu (new-dm-flag name val dm-collision-filter-material-pick-func))
                  )
              filter-menu)))
      (debug-menu-append-item menu (new-dm-submenu "Filter skip"
          (let ((filter-menu (new 'debug 'debug-menu ctx "Collision renderer filter skip menu")))
              (doenum (name val pc-pat-skip-hack)
                  (debug-menu-append-item filter-menu (new-dm-flag name val dm-collision-filter-skip-pick-func))
                  )
              filter-menu)))

      (new-dm-submenu "Collision renderer" menu)
      )
  )

(defun dm-lod-int ((arg0 int) (arg1 debug-menu-msg) (arg2 int) (arg3 int))
  (when (= arg1 (debug-menu-msg press))
    (case (/ arg0 8)
      ((0) (set! (-> *pc-settings* lod-force-tfrag) arg2))
      ((1) (set! (-> *pc-settings* lod-force-tie) arg2))
      ((2) (set! (-> *pc-settings* lod-force-ocean) arg2))
      ((3) (set! (-> *pc-settings* lod-force-actor) arg2))
      )
    )
  (case (/ arg0 8)
    ((0) (-> *pc-settings* lod-force-tfrag))
    ((1) (-> *pc-settings* lod-force-tie))
    ((2) (-> *pc-settings* lod-force-ocean))
    ((3) (-> *pc-settings* lod-force-actor))
    (else arg3)
    )
  )

(defun dm-subtitle-language ((blang int) (msg debug-menu-msg))
  (let ((lang (the pc-subtitle-lang (/ blang 8))))
    (when (= msg (debug-menu-msg press))
      (set! (-> *pc-settings* subtitle-language) lang))
    (= (-> *pc-settings* subtitle-language) lang)
    )
  )

(defun dm-text-language ((blang int) (msg debug-menu-msg))
  (let ((lang (the pc-subtitle-lang (/ blang 8))))
    (when (= msg (debug-menu-msg press))
      (set! (-> *pc-settings* text-language) lang))
    (= (-> *pc-settings* text-language) lang)
    )
  )

(defun dm-subtitle-setting ((setting symbol) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (set! (-> *pc-settings* subtitle-speaker?) setting))
  (= (-> *pc-settings* subtitle-speaker?) setting)
  )

(defun dm-mood-override-palette-pick-func ((bpal int) (msg debug-menu-msg))
  (let* ((pal (/ bpal 8))
         (cur-val (-> *mood-override-table* pal)))

      (when (= msg (debug-menu-msg press))
        (set! (-> *mood-override-table* pal) (if (= cur-val 0.0) 1.0 0.0))

        (when (not (= 'mult *mood-override-debug*))
      (set! *mood-override-debug* #f)
      (dotimes (i 8)
        (if (!= (-> *mood-override-table* i) 0.0)
            (set! *mood-override-debug* 'copy)))
        ))

      (= (-> *mood-override-table* pal) 1.0)
      )
  )

(defun dm-mood-override-pick-func ((kind symbol) (msg debug-menu-msg))
  (when (= msg (debug-menu-msg press))
    (if (= kind *mood-override-debug*)
        (set! *mood-override-debug* #f)
        (set! *mood-override-debug* kind)))
  (= kind *mood-override-debug*)
  )

(defun dm-mood-palette-float ((pal int) (arg1 debug-menu-msg) (newval float) (val float))
  (when (= arg1 (debug-menu-msg press))
    (set! (-> *mood-override-table* (/ pal 8)) newval))
  (-> *mood-override-table* (/ pal 8))
  )

(defun dm-anim-tester-x-flag-func ((action symbol) (msg debug-menu-msg))
  (case action
    (('at-show-joint-info)
      (if (= msg (debug-menu-msg press))
          (logxor! (-> *ATX-settings* flags) (atx-flags show-joints)))
      (return (logtest? (-> *ATX-settings* flags) (atx-flags show-joints)))
      )
    )
  #f)

(defun dm-anim-tester-x-func ((action symbol))
  (unless *atx*
      (atx-start))

  (case action
    (('pick-art-group)
     (set! (-> *atx* 0 edit-mode) (atx-edit-mode art-group))
     (false! *camera-read-buttons*)
     )
    (('at-pick-joint-anim)
     (when (-> *atx* 0 cur-art-group)
       (set! (-> *atx* 0 edit-mode) (atx-edit-mode anim))
       (false! *camera-read-buttons*)
       )
     )
    (('pick-mesh-geo)
     (when (-> *atx* 0 cur-art-group)
       (set! (-> *atx* 0 edit-mode) (atx-edit-mode mgeo))
       (false! *camera-read-buttons*)
       )
     )
    (('pick-joint-geo)
     (when (-> *atx* 0 cur-art-group)
       (set! (-> *atx* 0 edit-mode) (atx-edit-mode jgeo))
       (false! *camera-read-buttons*)
       )
     )
    (('at-cam-free-floating)
     (send-event *camera* 'change-state cam-free-floating 0)
     )
    (('at-cam-orbit)
     (send-event *camera* 'change-state cam-orbit 0)
     )
    )
  0)

(defun debug-menu-make-anim-tester-x-menu ((ctx debug-menu-context))
  (let ((menu (new 'debug 'debug-menu ctx "Anim Tester X menu")))
      ;; master toggle
      (debug-menu-append-item menu (new-dm-func "Start" #f atx-start))
      (debug-menu-append-item menu (new-dm-func "Stop"  #f atx-stop))
      (debug-menu-append-item menu (new-dm-var-float "Speed" (the int #f) (dm-lambda-float-var (-> *ATX-settings* speed)) 0.01 -10.0 10.0))
      (debug-menu-append-item menu (new-dm-var-float "Frame Num" (the int #f) (dm-lambda-float-var (-> *ATX-settings* frame-num)) 0.1 0.0 99999.0))
      (debug-menu-append-item menu (new-dm-func "Pick Art Group" 'pick-art-group dm-anim-tester-x-func))
      (debug-menu-append-item menu (new-dm-func "Pick Anim" 'at-pick-joint-anim dm-anim-tester-x-func))
      (debug-menu-append-item menu (new-dm-func "Pick Mesh" 'pick-mesh-geo dm-anim-tester-x-func))
      (debug-menu-append-item menu (new-dm-func "Pick Skeleton" 'pick-joint-geo dm-anim-tester-x-func))
      (debug-menu-append-item menu (new-dm-flag "Show Joint Info" 'at-show-joint-info dm-anim-tester-x-flag-func))
      (debug-menu-append-item menu (new-dm-func "Free Floating cam" 'at-cam-free-floating dm-anim-tester-x-func))
      (debug-menu-append-item menu (new-dm-func "Orbit cam" 'at-cam-orbit dm-anim-tester-x-func))

      (new-dm-submenu "Anim Tester X" menu)
      )
  )

(defun dm-music-player-func ((lst object))
  (kill-by-name 'dm-player *active-pool*)
  (set! *progress-flava* -1)
  (process-spawn-function process :name 'dm-player
    (lambda :behavior process ((lst pair))
      (loop
        (suspend)
        (set-setting! 'music (the-as symbol (car lst)) 0.0 0)
        (set! *progress-flava* (the-as int (cdr lst)))
        )
      )
      lst
    )
  )

(defun debug-menu-make-music-player-menu ((ctx debug-menu-context))
    (let ((music-menu (new 'debug 'debug-menu ctx "Music player menu")))
      (dotimes (i (-> *music-flava-name-list* length))
          (let* ((flava-list (-> *music-flava-name-list* i))
                 (level-name (new 'debug 'string 30 (text-id->string (-> flava-list 0))))
                 (lvl-menu (new 'debug 'debug-menu ctx (the-as string #f)))
                 )
            (dotimes (j (-> flava-list length))
                (let ((flava-name (new 'debug 'string 30 (text-id->string (-> flava-list j)))))
                  (when (and (string= (substring! *temp-string* level-name (- (length level-name) 11) (length level-name)) "-level-name")
                             (string= (substring! *temp-string* flava-name (- (length flava-name) 11) (length flava-name)) "-level-name"))
                      (copy-string<-string flava-name (symbol->string (ref *music-list* i)))
                    )
                  (unless (string= flava-name "zero")
                    (debug-menu-append-item lvl-menu (new-dm-func flava-name (dcons (ref *music-list* i) j) dm-music-player-func))
                    )
                )
              )
              (let ((menu-name (new 'debug 'string 30 (symbol->string (ref *music-list* i)))))
                (debug-menu-append-item music-menu (new-dm-submenu menu-name lvl-menu))
              )
            )
        )
        (debug-menu-append-item music-menu (new-dm-func "Reset" #f (lambda () (kill-by-name 'dm-player *active-pool*) (set! *progress-flava* -1))))
        (new-dm-submenu "Music player" music-menu)
      )
  )

(when (-> *debug-menu-context* root-menu)
  (debug-menu-append-item (-> *debug-menu-context* root-menu) (debug-menu-make-load-menu *debug-menu-context*))
  (debug-menu-append-item (-> *debug-menu-context* root-menu) (debug-menu-make-part-menu *debug-menu-context*))
  (debug-menu-append-item (-> *debug-menu-context* root-menu) (debug-menu-make-entity-menu *debug-menu-context*))
  ;; Scene menu TODO

  (debug-menu-append-item (-> *debug-menu-context* root-menu)
    (debug-menu-make-from-template *debug-menu-context*
      '(menu "PC Settings"
         (flag "Debug" #f ,(dm-lambda-boolean-flag (-> *pc-settings* debug?)))
         (flag "Use native vis" #f ,(dm-lambda-boolean-flag (-> *pc-settings* use-vis?)))
         (function "Toggle game aspect" #f ,(lambda ()
                                               (cond
                                                 ((= (-> *setting-control* default aspect-ratio) 'aspect4x3)
                                                  (set! (-> *setting-control* default aspect-ratio) 'aspect16x9)
                                                  )
                                                 (else
                                                  (set! (-> *setting-control* default aspect-ratio) 'aspect4x3)
                                                  )
                                                 )
                                                (set-aspect-ratio (-> *setting-control* default aspect-ratio))
                                               ))
         (flag "Auto aspect" #f ,(dm-lambda-boolean-flag (-> *pc-settings* aspect-ratio-auto?)))
         (menu "Aspect test"
            (function "4 x 3" #f ,(lambda () (set-aspect! *pc-settings* 4 3)))
            (function "16 x 9" #f ,(lambda () (set-aspect! *pc-settings* 16 9)))
            (function "64 x 27 (21:9)" #f ,(lambda () (set-aspect! *pc-settings* 64 27)))
            (function "16 x 10" #f ,(lambda () (set-aspect! *pc-settings* 16 10)))
            (function "2 x 1" #f ,(lambda () (set-aspect! *pc-settings* 2 1)))
            (function "37 x 20" #f ,(lambda () (set-aspect! *pc-settings* 37 20)))
            (function "21 x 9" #f ,(lambda () (set-aspect! *pc-settings* 21 9)))
            (function "64 x 18" #f ,(lambda () (set-aspect! *pc-settings* 64 18)))
            (int-var "Custom aspect X" #f ,(dm-lambda-int-var (-> *pc-settings* aspect-custom-x)) 20 1 #t 1 1000)
            (int-var "Custom aspect Y" #f ,(dm-lambda-int-var (-> *pc-settings* aspect-custom-y)) 20 1 #t 1 1000)
            (function "Custom" #f ,(lambda () (set-aspect! *pc-settings* (-> *pc-settings* aspect-custom-x) (-> *pc-settings* aspect-custom-y))))
            )
         (menu "Fullscreen"
            (function "Windowed" #f ,(lambda () (set-display-mode! *pc-settings* 'windowed)))
            (function "Fullscreen" #f ,(lambda () (set-display-mode! *pc-settings* 'fullscreen)))
            (function "Borderless" #f ,(lambda () (set-display-mode! *pc-settings* 'borderless)))
            )
         (menu "Sizes"
            (function "640 x 480" #f ,(lambda () (set-size! *pc-settings* 640 480)))
            (function "640 x 360" #f ,(lambda () (set-size! *pc-settings* 640 360)))
            (function "720 x 540" #f ,(lambda () (set-size! *pc-settings* 720 540)))
            (function "960 x 540" #f ,(lambda () (set-size! *pc-settings* 960 540)))
            (function "800 x 600" #f ,(lambda () (set-size! *pc-settings* 800 600)))
            (function "960 x 720" #f ,(lambda () (set-size! *pc-settings* 960 720)))
            (function "1280 x 720" #f ,(lambda () (set-size! *pc-settings* 1280 720)))
            (function "1024 x 768" #f ,(lambda () (set-size! *pc-settings* 1024 768)))
            (function "1366 x 768" #f ,(lambda () (set-size! *pc-settings* 1366 768)))
            (function "1280 x 960" #f ,(lambda () (set-size! *pc-settings* 1280 960)))
            (function "1440 x 1080" #f ,(lambda () (set-size! *pc-settings* 1440 1080)))
            (function "1920 x 1080" #f ,(lambda () (set-size! *pc-settings* 1920 1080)))
            (function "1920 x 1440" #f ,(lambda () (set-size! *pc-settings* 1920 1440)))
            (function "2560 x 1440" #f ,(lambda () (set-size! *pc-settings* 2560 1440)))
            (function "2880 x 2160" #f ,(lambda () (set-size! *pc-settings* 2880 2160)))
            (function "3840 x 2160" #f ,(lambda () (set-size! *pc-settings* 3840 2160)))
            (function "512 x 224" #f ,(lambda () (set-size! *pc-settings* 512 224)))
            (function "512 x 256" #f ,(lambda () (set-size! *pc-settings* 512 256)))
            (function "512 x 448" #f ,(lambda () (set-size! *pc-settings* 512 448)))
            (function "512 x 512" #f ,(lambda () (set-size! *pc-settings* 512 512)))
            )
         (menu "Secrets"
            (menu "PC cheats"
               (flag "Big head jak" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) big-head)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) big-head)))
               (flag "Small head jak" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) small-head)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) small-head)))
               (flag "Big fist jak" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) big-fist)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) big-fist)))
               (flag "Big head npcs" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) big-head-npc)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) big-head-npc)))
               (flag "Huge head jak" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) huge-head)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) huge-head)))
               (flag "Mirrored mode" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) mirror)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) mirror)))
               (flag "Blue eco" #f ,(lambda (arg (msg debug-menu-msg))
                                               (when (= msg (debug-menu-msg press))
                                                 (logclear! (-> *pc-settings* cheats) (pc-cheats eco-red eco-yellow eco-green))
                                                 (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) eco-blue)
                                                 )
                                               (pc-cheats? (-> *pc-settings* cheats) eco-blue)))
               (flag "Red eco" #f ,(lambda (arg (msg debug-menu-msg))
                                              (when (= msg (debug-menu-msg press))
                                                (logclear! (-> *pc-settings* cheats) (pc-cheats eco-blue eco-yellow eco-green))
                                                (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) eco-red)
                                                )
                                               (pc-cheats? (-> *pc-settings* cheats) eco-red)))
               (flag "Green eco" #f ,(lambda (arg (msg debug-menu-msg))
                                                (when (= msg (debug-menu-msg press))
                                                  (logclear! (-> *pc-settings* cheats) (pc-cheats eco-red eco-yellow eco-blue))
                                                  (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) eco-green)
                                                  )
                                                 (pc-cheats? (-> *pc-settings* cheats) eco-green)))
               (flag "Yellow eco" #f ,(lambda (arg (msg debug-menu-msg))
                                                 (when (= msg (debug-menu-msg press))
                                                   (logclear! (-> *pc-settings* cheats) (pc-cheats eco-red eco-blue eco-green))
                                                   (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) eco-yellow)
                                                   )
                                                 (pc-cheats? (-> *pc-settings* cheats) eco-yellow)))
               (flag "Invincibility" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (logclear! (-> *target* state-flags) 16)
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) invinc)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) invinc)))
               (flag "Blue sidekick" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) sidekick-blue)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) sidekick-blue)))
               (flag "All flavas" #f ,(lambda (arg (msg debug-menu-msg))
                                                 (when (= msg (debug-menu-msg press))
                                                   (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) tunes)
                                                   )
                                                 (pc-cheats? (-> *pc-settings* cheats) tunes)))
               (flag "Real time tod" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) sky)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) sky)))
               (flag "No textures" #f ,(lambda (arg (msg debug-menu-msg))
                                                    (when (= msg (debug-menu-msg press))
                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) no-tex)
                                                      )
                                                    (pc-cheats? (-> *pc-settings* cheats) no-tex)))
;;               (flag "Hard rats" #f ,(lambda (arg (msg debug-menu-msg))
;;                                                    (when (= msg (debug-menu-msg press))
;;                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) hard-rats)
;;                                                      )
;;                                                    (pc-cheats? (-> *pc-settings* cheats) hard-rats)))
;;               (flag "Hero mode" #f ,(lambda (arg (msg debug-menu-msg))
;;                                                    (when (= msg (debug-menu-msg press))
;;                                                      (pc-cheat-toggle-and-tune (-> *pc-settings* cheats) hero-mode)
;;                                                      )
;;                                                    (pc-cheats? (-> *pc-settings* cheats) hero-mode)))
               )
            )
         (flag "Letterbox" #f ,(dm-lambda-boolean-flag (-> *pc-settings* letterbox?)))
         (flag "Skip movies" #f ,(dm-lambda-boolean-flag (-> *pc-settings* skip-movies?)))
         (flag "Money starburst" #f ,(dm-lambda-boolean-flag (-> *pc-settings* money-starburst?)))
         (flag "Subtitles" #f ,(dm-lambda-boolean-flag (-> *pc-settings* subtitles?)))
         (flag "Hinttitles" #f ,(dm-lambda-boolean-flag (-> *pc-settings* hinttitles?)))
         (menu "Subtitle speaker"
            (flag "Off" #f dm-subtitle-setting)
            (flag "On" #t dm-subtitle-setting)
            (flag "Auto" auto dm-subtitle-setting)
            )
         (menu "Subtitle language"
            (flag "english" 0 dm-subtitle-language)
            (flag "french" 1 dm-subtitle-language)
            (flag "german" 2 dm-subtitle-language)
            (flag "spanish" 3 dm-subtitle-language)
            (flag "italian" 4 dm-subtitle-language)
            (flag "uk-english" 6 dm-subtitle-language)
            (flag "br-portuguese" 13 dm-subtitle-language)
            )
         (menu "Text language"
            (flag "english" 0 dm-text-language)
            (flag "french" 1 dm-text-language)
            (flag "german" 2 dm-text-language)
            (flag "spanish" 3 dm-text-language)
            (flag "italian" 4 dm-text-language)
            (flag "japanese" 5 dm-text-language)
            (flag "uk-english" 6 dm-text-language)
            (flag "br-portuguese" 13 dm-text-language)
            (flag "hungarian" 14 dm-text-language)
            )
         (flag "Fallback Text Search" #f ,(dm-lambda-boolean-flag *fallback-text-lookup?*))
         (flag "Discord RPC" #t ,(dm-lambda-boolean-flag (-> *pc-settings* discord-rpc?)))
         (flag "Speedrunner Mode" #t ,(dm-lambda-boolean-flag (-> *pc-settings* speedrunner-mode?)))
         (menu "PS2 settings"
            ;(flag "PS2 Load speed" #f ,(dm-lambda-boolean-flag (-> *pc-settings* ps2-read-speed?)))
            (flag "PS2 Particles" #f ,(dm-lambda-boolean-flag (-> *pc-settings* ps2-parts?)))
            ;(flag "PS2 Music" #f ,(dm-lambda-boolean-flag (-> *pc-settings* ps2-music?)))
            ;(flag "PS2 Sound effects" #f ,(dm-lambda-boolean-flag (-> *pc-settings* ps2-se?)))
            ;(flag "PS2 Hints" #f ,(dm-lambda-boolean-flag (-> *pc-settings* ps2-hints?)))
            )
         (menu "Level of detail"
               (flag "PS2 LOD     " #f ,(dm-lambda-boolean-flag (-> *pc-settings* ps2-lod-dist?)))
               (flag "Force Envmap" #f ,(dm-lambda-boolean-flag (-> *pc-settings* force-envmap?)))
            (int-var "LOD Tfrag" 0 dm-lod-int 0 1 #t 0 2)
            (int-var "LOD Tie" 1 dm-lod-int 0 1 #t 0 3)
            ;(int-var "LOD Ocean" 2 dm-lod-int 0 1 #t 0 3)
            (int-var "LOD Actor" 3 dm-lod-int 0 1 #t 0 3)
            (function "Best quality" #f ,(lambda () (set! (-> *pc-settings* lod-force-tfrag) 0)
                                                    (set! (-> *pc-settings* lod-force-tie) 0)
                                                    ;(set! (-> *pc-settings* lod-force-ocean) 0)
                                                    (set! (-> *pc-settings* lod-force-actor) 0)
                                                    ))
            (function "Worst quality" #f ,(lambda () (set! (-> *pc-settings* lod-force-tfrag) 2)
                                                    (set! (-> *pc-settings* lod-force-tie) 3)
                                                    ;(set! (-> *pc-settings* lod-force-ocean) 2)
                                                    (set! (-> *pc-settings* lod-force-actor) 3)
                                                    ))
            )
        (menu "Framerate"
          (flag "60" #f ,(lambda (arg (msg debug-menu-msg)) (when (= msg (debug-menu-msg press)) (set-frame-rate! *pc-settings* 60))
                                                            (= (-> *pc-settings* target-fps) 60)))
          (flag "100" #f ,(lambda (arg (msg debug-menu-msg)) (when (= msg (debug-menu-msg press)) (set-frame-rate! *pc-settings* 100))
                                                            (= (-> *pc-settings* target-fps) 100)))
          (flag "150" #f ,(lambda (arg (msg debug-menu-msg)) (when (= msg (debug-menu-msg press)) (set-frame-rate! *pc-settings* 150))
                                                            (= (-> *pc-settings* target-fps) 150)))
            )
        (menu "MSAA"
          (flag "Off" #f ,(lambda (arg (msg debug-menu-msg)) (when (= msg (debug-menu-msg press)) (set! (-> *pc-settings* gfx-msaa) 1))
                                                             (= (-> *pc-settings* gfx-msaa) 1)))
          (flag "x2" #f ,(lambda (arg (msg debug-menu-msg)) (when (= msg (debug-menu-msg press)) (set! (-> *pc-settings* gfx-msaa) 2))
                                                            (= (-> *pc-settings* gfx-msaa) 2)))
          (flag "x4" #f ,(lambda (arg (msg debug-menu-msg)) (when (= msg (debug-menu-msg press)) (set! (-> *pc-settings* gfx-msaa) 4))
                                                            (= (-> *pc-settings* gfx-msaa) 4)))
          (flag "x8" #f ,(lambda (arg (msg debug-menu-msg)) (when (= msg (debug-menu-msg press)) (set! (-> *pc-settings* gfx-msaa) 8))
                                                            (= (-> *pc-settings* gfx-msaa) 8)))
          (flag "x16" #f ,(lambda (arg (msg debug-menu-msg)) (when (= msg (debug-menu-msg press)) (set! (-> *pc-settings* gfx-msaa) 16))
                                                             (= (-> *pc-settings* gfx-msaa) 16)))
            )
         (flag "V-sync" #f ,(dm-lambda-boolean-flag (-> *pc-settings* vsync?)))
         (flag "All actors" #f ,(dm-lambda-boolean-flag (-> *pc-settings* force-actors?)))
         (flag "Display actor counts" *display-actor-counts* dm-boolean-toggle-pick-func)
         (flag "Display git commit" *display-sha* dm-boolean-toggle-pick-func)
         (flag "Extra hud elements" #f ,(dm-lambda-boolean-flag (-> *pc-settings* extra-hud?)))
         (flag "Music fadein" #f ,(dm-lambda-boolean-flag (-> *pc-settings* music-fadein?)))
         (flag "Music fadeout" #f ,(dm-lambda-boolean-flag (-> *pc-settings* music-fadeout?)))
         (function "Reset" #f ,(lambda () (reset *pc-settings*)))
         (function "Save" #f ,(lambda () (commit-to-file *pc-settings*)))
         (function "Load" #f ,(lambda () (load-settings *pc-settings*)))
         )
      )
    )
  (let* ((prog-menu (new 'debug 'debug-menu *debug-menu-context* "Progress menu"))
         (prog-menu-node (new-dm-submenu "Progress" prog-menu))
         (other-menu-node
            (debug-menu-make-from-template *debug-menu-context*
              '(menu "Other"
                 (flag "DECI Count" *display-deci-count* dm-boolean-toggle-pick-func)
                 ;(flag "Actor graph" *display-actor-graph* dm-boolean-toggle-pick-func)
                 (flag "Update vis outside bsp" *update-leaf-when-outside-bsp* dm-boolean-toggle-pick-func)
                 (flag "Pad display" *display-pad-debug* dm-boolean-toggle-pick-func)
                 (flag "Display actor bank" *display-actor-bank* dm-boolean-toggle-pick-func)
                 (flag "Heap status" *display-heap-status* dm-boolean-toggle-pick-func)
                 (flag "Bug report" *display-bug-report* dm-boolean-toggle-pick-func)
                 (flag "Text boxes" *display-text-box* dm-boolean-toggle-pick-func)
                 (flag "Sidekick stats" *display-sidekick-stats* dm-boolean-toggle-pick-func)
                 (float-var "Actor birth dist" #f ,(dm-lambda-meters-var (-> *ACTOR-bank* birth-dist)) 20 1 #t 0 10000 1)
                 (float-var "Actor pause dist" #f ,(dm-lambda-meters-var (-> *ACTOR-bank* pause-dist)) 20 1 #t 0 10000 1)
                 (menu "Mood override"
                    (function "-- SIMPLE OVERRIDE" #f nothing)
                    (flag "Palette 0" 0 dm-mood-override-palette-pick-func)
                    (flag "Palette 1" 1 dm-mood-override-palette-pick-func)
                    (flag "Palette 2" 2 dm-mood-override-palette-pick-func)
                    (flag "Palette 3" 3 dm-mood-override-palette-pick-func)
                    (flag "Palette 4" 4 dm-mood-override-palette-pick-func)
                    (flag "Palette 5" 5 dm-mood-override-palette-pick-func)
                    (flag "Palette 6" 6 dm-mood-override-palette-pick-func)
                    (flag "Palette 7" 7 dm-mood-override-palette-pick-func)
                    (menu "Advanced"
                        (flag "Overwrite" copy dm-mood-override-pick-func)
                        (flag "Multiply" mult dm-mood-override-pick-func)
                        (float-fixed-var "Palette 0 Amt" 0 dm-mood-palette-float 0 10 #t 0 1000 3)
                        (float-fixed-var "Palette 1 Amt" 1 dm-mood-palette-float 0 10 #t 0 1000 3)
                        (float-fixed-var "Palette 2 Amt" 2 dm-mood-palette-float 0 10 #t 0 1000 3)
                        (float-fixed-var "Palette 3 Amt" 3 dm-mood-palette-float 0 10 #t 0 1000 3)
                        (float-fixed-var "Palette 4 Amt" 4 dm-mood-palette-float 0 10 #t 0 1000 3)
                        (float-fixed-var "Palette 5 Amt" 5 dm-mood-palette-float 0 10 #t 0 1000 3)
                        (float-fixed-var "Palette 6 Amt" 6 dm-mood-palette-float 0 10 #t 0 1000 3)
                        (float-fixed-var "Palette 7 Amt" 7 dm-mood-palette-float 0 10 #t 0 1000 3)
                        )
                    )
                 (flag "Joint names" *display-joint-names* dm-boolean-toggle-pick-func)
                 (flag "Bone lines" *display-bones* dm-boolean-toggle-pick-func)
                 )
              ))
         (other-menu (-> (the-as debug-menu-item-submenu other-menu-node) submenu))
         )
    (dotimes (i (progress-screen max))
      (debug-menu-append-item prog-menu
          (new-dm-func (new 'debug 'string 0 (enum->string progress-screen i)) i
                        (lambda ((val progress-screen))
                          (activate-progress *dproc* val)
                          (set-master-mode 'progress)
                          )
                        ))
      )
    (debug-menu-append-item other-menu prog-menu-node)

    (debug-menu-append-item (-> *debug-menu-context* root-menu) other-menu-node)
    )

  (debug-menu-append-item (-> (the debug-menu-item-submenu (ref (-> *debug-menu-context* root-menu items) 4)) submenu)
                          (debug-menu-make-collision-renderer-menu *debug-menu-context*))

  (debug-menu-append-item (-> (the debug-menu-item-submenu (car (-> *debug-menu-context* root-menu items))) submenu)
                          (debug-menu-make-anim-tester-x-menu *debug-menu-context*))

  (debug-menu-append-item (-> (the debug-menu-item-submenu (ref (-> (the debug-menu-item-submenu (ref (-> *debug-menu-context* root-menu items) 19)) submenu items) 7)) submenu)
                          (debug-menu-make-music-player-menu *debug-menu-context*))

  )

(defun bg-custom ((level-name symbol))
  "Modified version of bg for the PC Port custom levels."

  ;; lookup info
  (format 0 "(bg-custom ~A)%" level-name)
  (let ((lev-info (lookup-level-info level-name)))
    (when (= lev-info default-level)
      (format 0 "Unable to (bg-custom ~A), the level was not found in *level-load-list*~%" level-name)
      (return #f)
      )

    ;; kill jak (rip)
    (format 0 "doing stop~%")
    (stop 'play)

    ;; kill levels
    (dotimes (i 2)
      (unload! (-> *level* data i))
      )

    ;; enable visiblity. the custom level won't use it, but we want it on so other levels can be loaded.
    (set! (-> *level* vis?) #t)

    ;; disable border and play mode to prevent loading levels
    (set! (-> *level* border?) #f)
    (set! (-> *setting-control* default border-mode) #f)
    (set! (-> *level* play?) #f)

    ;; disable actor vis
    (set! *vis-actors* #f)

    (format 0 "doing level load~%")
    ;; allocate level. This may start the loading process, but won't finish it.
    (let ((lev (level-get-for-use *level* level-name 'active)))
      (when (not lev)
        (format 0 "Unable to load level, could not level-get-for-use~%")
        (return #f)
        )
      (format 0 "about to start load loop, game will freeze and hopefully come back soon~%")

      ;; spin in a loop and load it. This will cause the game to freeze during the load,
      ;; but this is good enough for now.
      (while (or (= (-> lev status) 'loading)
                 (= (-> lev status) 'loading-bt)
                 (= (-> lev status) 'login)
                 )
        (load-continue lev)
        )

      (when (not (-> lev info continues))
        (format 0 "level info has no continues, can't load it.~%")
        )

      (let ((cont (car (-> lev info continues))))
        (start 'play (the continue-point cont))
        )

      (vis-load lev)
      (set! (-> lev all-visible?) #f)
      (set! (-> lev force-all-visible?) #t)

      ;; reset things
      ;(initialize! *game-info* 'game (the-as game-save #f) (the-as string #f))
      )
    )
  )