view clojure/com/aurellem/assembly.clj @ 124:f8dadd9478a5

fixed problem with mode transitions
author Robert McIntyre <rlm@mit.edu>
date Sat, 17 Mar 2012 01:23:47 -0500
parents c9a280b8bd1c
children d2e00c923bad
line wrap: on
line source
1 (ns com.aurellem.assembly
2 (:use (com.aurellem gb-driver vbm title items))
3 (:import [com.aurellem.gb_driver SaveState]))
5 (defn mid-game []
6 (read-state "mid-game"))
8 (defn inject-assembly
9 ([^SaveState state
10 program-counter registers
11 assembly-code]
12 (let [scratch-memory (memory state)]
13 ;; inject assembly code
14 (dorun (map (fn [index val]
15 (aset scratch-memory index val))
16 (range program-counter
17 (+ program-counter (count assembly-code)))
18 assembly-code))
19 (-> state
20 (write-memory! scratch-memory)
21 (write-registers! registers)
22 (PC! program-counter)))))
24 (defn inject-item-assembly
25 ([^SaveState state assembly-code]
26 (inject-assembly state (inc item-list-start)
27 (registers state)
28 assembly-code))
29 ([assembly-code]
30 (inject-item-assembly @current-state assembly-code)))
32 (defn info
33 ([^SaveState state]
34 (println (format "PC: 0x%04X" (PC state)))
35 (println "Instruction:"
36 (format "0x%02X" (aget (memory state) (PC state))))
37 state))
39 (defn print-interrupt
40 [^SaveState state]
41 (println (format "IE: %d" (IE state)))
42 state)
44 (defn print-listing [state begin end]
45 (dorun (map
46 (fn [opcode line]
47 (println (format "0x%04X: 0x%02X" line opcode)))
48 (subvec (vec (memory state)) begin end)
49 (range begin end)))
50 state)
52 (defn run-assembly
53 ([info-fn assembly n]
54 (let [final-state
55 (reduce (fn [state _]
56 (tick (info-fn state)))
57 (inject-item-assembly
58 (mid-game) assembly)
59 (range n))]
60 final-state))
61 ([assembly n]
62 (run-assembly info assembly n)))
64 (def buttons-port 0xFF00)
66 (defn A [state]
67 (bit-shift-right (bit-and 0x0000FF00 (AF state)) 8))
69 (defn binary-str [num]
70 (format "%08d"
71 (Integer/parseInt
72 (Integer/toBinaryString num) 10)))
74 (defn view-register [state name reg-fn]
75 (println (format "%s: %s" name
76 (binary-str (reg-fn state))))
77 state)
79 (defn view-memory [state mem]
80 (println (format "mem 0x%04X = %s" mem
81 (binary-str (aget (memory state) mem))))
82 state)
84 (defn trace [state]
85 (loop [program-counters [(first (registers @current-state)) ]
86 opcodes [(aget (memory @current-state) (PC @current-state))]]
87 (let [frame-boundary?
88 (com.aurellem.gb.Gb/tick)]
89 (if frame-boundary?
90 [program-counters opcodes]
91 (recur
92 (conj program-counters
93 (first (registers @current-state)))
94 (conj opcodes
95 (aget (memory @current-state)
96 (PC @current-state))))))))
98 (defn print-trace [state n]
99 (let [[program-counters opcodes] (trace state)]
100 (dorun (map (fn [pc op] (println (format "%04X: 0x%02X" pc op)))
101 (take n program-counters)
102 (take n opcodes)))))
104 (defn good-trace []
105 (-> (mid-game) (tick) (IE! 0)
106 (set-inv-mem [0x00 0x00 0X00 0x00])
107 (PC! item-list-start)(print-interrupt)
108 (info) (tick) (info) (tick) (info)))
110 (defn read-down-button []
111 (-> (tick (mid-game))
112 (IE! 0) ; disable interrupts
113 (inject-item-assembly
114 ;; write 00010000 to 0xFF00 to select joypad
115 [0x18 ;D31D ; jump over
116 0x01 ;D31E ; the next 8 bits
117 ;D31F
118 (Integer/parseInt "00100000" 2) ; data section
120 0xFA ;D320 ; load (D31F) into A
121 0x1F ;D321 -->
122 0xD3 ;D322 --> D31F
124 0xEA ;D323 ; load (A), which is
125 0x00 ;D324 --> ; 00010000, into FF00
126 0xFF ;D325 --> FF00
128 0x18 ;D326 ; this is the place where
129 0x01 ;D327 ; we will store whether
130 0x00 ;D328 ; "down" is pressed.
132 0xFA ;D329 ; (FF00) -> A
133 0x00 ;D32A
134 0xFF ;D32B
136 0xCB ;D32C ; Test whether "down"
137 0x5F ;D32D ; is pressed.
139 0x28 ;D32E ; if down is pressed,
140 0x03 ;D32F ; skip the next section
141 ; of code.
142 ;; down-is-not-pressed
143 0xC3 ;D330
144 0x1D ;D331 ; return to beginning
145 0xD3 ;D332
147 ;; down-is-pressed
148 0xEA ;D334 ; write A to D328 if
149 0x28 ;D335 ; "down" was pressed
150 0xD3 ;D336
152 0xC3 ;D330
153 0x1D ;D331 ; return to beginning
154 0xD3 ;D332
155 ])))
157 (defn test-read-down []
158 (= (view-memory (step (step (read-down-button) [:d])) 0xD328)
159 (view-memory (step (step (read-down-button))) 0xD328)))
161 (defn count-frames []
162 (-> (tick (mid-game))
163 (IE! 0) ; disable interrupts
164 (inject-item-assembly
165 [0x18 ;D31D ; jump over
166 0x02 ;D31E ; the next 2 bytes
167 0x00 ;D31F ; frame-count
168 0x00 ;D320 ; v-blank-prev
170 0xFA ;D321
171 0x41 ;D322 ; load (FF41) into A
172 0xFF ;D323 ; this contains mode flags
174 ;; if we're in v-blank, the bit-1 is 0
175 ;; and bit-2 is 1 Otherwise, it is not v-blank.
176 0xCB ;D324 ; test bit-1 of A
177 0x4F ;D325
179 0xC2 ;D326 ; if bit-1 is not 0
180 0x44 ;D327 ; GOTO not-v-blank
181 0xD3 ;D328
183 0xCB ;D329 ; test bit-0 of A
184 0x47 ;D32A
186 0xCA ;D32B ; if bit-0 is not 1
187 0x44 ;D32C ; GOTO not-v-blank
188 0xD3 ;D32D
189 ;;; in v-blank mode
190 ;; if v-blank-prev was 0,
191 ;; increment frame-count
193 0xFA ;D32E ; load v-blank-prev to A
194 0x20 ;D32F
195 0xD3 ;D330
197 0xCB ;D331
198 0x47 ;D332 ; test bit-0 of A
200 0x20 ;D333 ; skip next section
201 0x07 ;D334 ; if v-blank-prev was not zero
203 ;; v-blank was 0, increment frame-count
204 0xFA ;D335 ; load frame-count into A
205 0x1F ;D336
206 0xD3 ;D337
208 0x3C ;D338 ; inc A
210 0xEA ;D339 ; load A into frame-count
211 0x1F ;D33A
212 0xD3 ;D33B
214 ;; set v-blank-prev to 1
215 0x3E ;D33C ; load 1 into A
216 0x01 ;D33D
218 0xEA ;D33E ; load A into v-blank-prev
219 0x20 ;D33F
220 0xD3 ;D340
222 0xC3 ;D341 ; return to beginning
223 0x1D ;D342
224 0xD3 ;D343
226 ;;; not in v-blank mode
227 ;; set v-blank-prev to 0
228 0x3E ;D344 ; load 0 into A
229 0x00 ;D345
231 0xEA ;D346 ; load A into v-blank-prev
232 0x20 ;D347
233 0xD3 ;D348
235 0xC3 ;D349 ; return to beginning
236 0x1D ;D34A
237 0xD3 ;D34B
238 ])))
240 (defn step-count-frames []
241 (-> (read-down-button)
242 (info)
243 (tick) ;; skip over data section
244 (info)
245 (view-register "Register A" A)
246 (tick) ;; load-data into A
247 (view-register "Register A" A)
248 (info)
249 (view-memory 0xFF00)
250 (tick) ;; load A into 0xFF00
251 (view-memory 0xFF00)
252 (info)
253 (tick)
254 (info)
255 (tick)
256 (info)
257 (tick)
258 (info)
259 (tick)
260 (info)
261 (tick)
262 (info)
263 (tick)
264 (print-inventory)))
266 (defn test-count-frames []
267 (= 255 (aget (memory ((apply comp (repeat 255 step))
268 (count-frames)))
269 0xD31F)))
271 ;; specs for main bootstrap program
272 ;; starts in "mode-select" mode
273 ;; Each button press takes place in a single frame.
274 ;; mode-select-mode takes one of the main buttons
275 ;; which selects one of up to eight modes
276 ;; mode 1 activated by the "A" button
277 ;; the next two button presses indicates the start
278 ;; memory location which to which the bootstrap
279 ;; program will write.
280 ;; This is done by using each of the eight buttons to
281 ;; spell out an 8 bit number. The order of buttons is
282 ;; [:d :u :l :r :start :select :b :a]
283 ;; [:a :start :l] --> 00101001
285 ;; the next button press determines how many bytes are to be
286 ;; written, starting at the start position.
288 ;; then, the actual bytes are entered and are written to the
289 ;; start address in sequence.
291 (defn input-number-assembly []
292 [0x18 ;D31D ; jump over
293 0x02 ;D31E ; the next 2 bytes
294 0x00 ;D31F ; frame-count
295 0x00 ;D320 ; v-blank-prev
297 0xFA ;D321
298 0x41 ;D322 ; load (FF41) into A
299 0xFF ;D323 ; this contains mode flags
301 ;; if we're in v-blank, the bit-1 is 0
302 ;; and bit-2 is 1 Otherwise, it is not v-blank.
303 0xCB ;D324 ; test bit-1 of A
304 0x4F ;D325
306 0xC2 ;D326 ; if bit-1 is not 0
307 0x44 ;D327 ; GOTO not-v-blank
308 0xD3 ;D328
310 0xCB ;D329 ; test bit-0 of A
311 0x47 ;D32A
313 0xCA ;D32B ; if bit-0 is not 1
314 0x44 ;D32C ; GOTO not-v-blank
315 0xD3 ;D32D
317 ;;; in v-blank mode
319 ;; if v-blank-prev was 0,
320 ;; increment frame-count
322 0xFA ;D32E ; load v-blank-prev to A
323 0x20 ;D32F
324 0xD3 ;D330
326 0xCB ;D331
327 0x47 ;D332 ; test bit-0 of A
329 0x20 ;D333 ; skip next section
330 0x07 ;D334 ; if v-blank-prev was not zero
332 ;; v-blank was 0, increment frame-count
333 0xFA ;D335 ; load frame-count into A
334 0x1F ;D336
335 0xD3 ;D337
337 0x3C ;D338 ; inc A
339 0xEA ;D339 ; load A into frame-count
340 0x1F ;D33A
341 0xD3 ;D33B
343 ;; set v-blank-prev to 1
344 0x3E ;D33C ; load 1 into A
345 0x01 ;D33D
347 0xEA ;D33E ; load A into v-blank-prev
348 0x20 ;D33F
349 0xD3 ;D340
351 0xC3 ;D341 ; GOTO input handling code
352 0x4E ;D342
353 0xD3 ;D343
355 ;;; not in v-blank mode
356 ;; set v-blank-prev to 0
357 0x3E ;D344 ; load 0 into A
358 0x00 ;D345
360 0xEA ;D346 ; load A into v-blank-prev
361 0x20 ;D347
362 0xD3 ;D348
364 0xC3 ;D349 ; return to beginning
365 0x1D ;D34A
366 0xD3 ;D34B
368 0x00 ;D34C ; these are here
369 0x00 ;D34D ; for glue
372 ;;; calculate input number based on button presses
373 0x18 ;D34E ; skip next 3 bytes
374 0x03 ;D34F
375 ;D350
376 (Integer/parseInt "00100000" 2) ; select directional pad
377 ;D351
378 (Integer/parseInt "00010000" 2) ; select buttons
379 0x00 ;D352 ; input-number
381 ;; select directional pad, store low bits in B
383 0xFA ;D353 ; load (D350) into A
384 0x50 ;D354 -->
385 0xD3 ;D355 --> D31F
387 0xEA ;D356 ; load (A), which is
388 0x00 ;D357 --> ; 00010000, into FF00
389 0xFF ;D358 --> FF00
391 0x06 ;D359
392 ;D35A
393 (Integer/parseInt "11110000" 2) ; "11110000" -> B
394 0xFA ;D35B ; (FF00) -> A
395 0x00 ;D35C
396 0xFF ;D35D
398 0xCB ;D35E ; swap nybbles on A
399 0x37 ;D35F
400 0xA0 ;D360 ; (AND A B) -> A
401 0x47 ;D361 ; A -> B
403 ;; select buttons store bottom bits in C
405 0xFA ; ; load (D351) into A
406 0x51 ; -->
407 0xD3 ; --> D31F
409 0xEA ; ; load (A), which is
410 0x00 ; --> ; 00001000, into FF00
411 0xFF ; --> FF00
413 0x0E ;
414 (Integer/parseInt "00001111" 2) ; "00001111" -> C
416 0xFA ; ; (FF00) -> A
417 0x00 ;
418 0xFF ;
420 0xA1 ; ; (AND A C) -> A
421 0x4F ; ; A -> C
423 ;; combine the B and C registers into the input number
424 0x79 ; ; C -> A
425 0xB0 ; ; (OR A B) -> A
426 0x2F ; ; negate A
428 0xEA ; ; store A into input-number
429 0x52 ;
430 0xD3 ;
432 0xC3 ; ; return to beginning
433 0x1D ;
434 0xD3 ;
435 ])
437 (defn input-number []
438 (-> (tick (mid-game))
439 (IE! 0) ; disable interrupts
440 (inject-item-assembly (input-number-assembly))))
442 (defn test-input-number
443 "Input freestyle buttons and observe the effects at the repl."
444 []
445 (set-state! (input-number))
446 (dotimes [_ 90000] (step (view-memory @current-state 0xD352))))
448 (defn write-memory-assembly []
450 [
451 ;; Main Timing Loop
452 ;; Constantly check for v-blank and Trigger main state machine on
453 ;; every transtion from v-blank to non-v-blank.
455 0x18 ; D31D ; Variable declaration
456 0x02 ; D31E
457 0x00 ; D31F ; frame-count
458 0x00 ; D320 ; v-blank-prev
460 0xFA ; D321 ; load v-blank mode flags into A
461 0x41 ; D322
462 0xFF ; D323
464 ;; Branch dependent on v-blank. v-blank happens when the last two
465 ;; bits in A are "01"
466 0xCB ; D324
467 0x4F ; D325
469 0xC2 ; D326 ; if bit-1 is not 0, then
470 0x3E ; D327 ; GOTO non-v-blank.
471 0xD3 ; D328
473 0xCB ; D329
474 0x47 ; D32A
476 0xCA ; D32B ; if bit-0 is not 1, then
477 0x3E ; D32C ; GOTO non-v-blank.
478 0xD3 ; D32D
480 ;; V-Blank
481 ;; Activate state-machine if this is a transition event.
483 0xFA ; D32E ; load v-bank-prev into A
484 0x20 ; D32F
485 0xD3 ; D330
487 0xFE ; D331 ; compare A to 0. >--------\
488 0x00 ; D332 \
489 ; |
490 ;; set v-blank-prev to 1. |
491 0x3E ; D333 ; load 1 into A. |
492 0x01 ; D334 |
493 ; |
494 0xEA ; D335 ; load A into v-blank-prev |
495 0x20 ; D336 |
496 0xD3 ; D337 |
497 ; /
498 ;; if v-blank-prev was 0, activate state-machine <------/
499 0xCA ; D338 ; if v-blank-prev
500 0x46 ; D339 ; was 0,
501 0xD3 ; D33A ; GOTO state-machine
503 0xC3 ; D33B
504 0x1D ; D33C
505 0xD3 ; D33D ; GOTO beginning
506 ;; END V-blank
508 ;; Non-V-Blank
509 ;; Set v-blank-prev to 0
510 0x3E ; D33E ; load 0 into A
511 0x00 ; D33F
513 0xEA ; D340 ; load A into v-blank-prev
514 0x20 ; D341
515 0xD3 ; D342
517 0xC3 ; D343
518 0x1D ; D344
519 0xD3 ; D345 ; GOTO beginning
520 ;; END Not-V-Blank
523 ;; Main State Machine -- Input Section
524 ;; This is called once every frame.
525 ;; It collects input and uses it to drive the
526 ;; state transitions.
528 ;; Increment frame-count
529 0xFA ; D346 ; load frame-count into A
530 0x1F ; D347
531 0xD3 ; D348
533 0x3C ; D349 ; inc A
535 0xEA ; D34A
536 0x1F ; D34B ; load A into frame-count
537 0xD3 ; D34C
539 0x00 ; D34D ; glue :)
542 ;;;;;;;;; BEGIN RLM DEBUG
543 ;;0xC3 ;; jump to beginning
544 ;;0x1D
545 ;;0xD3
546 ;;;;;;;;; END RLM DEBUG
549 0x18 ;D34E ; skip next 3 bytes
550 0x03 ;D34F
551 ;D350
552 (Integer/parseInt "00100000" 2) ; select directional pad
553 ;D351
554 (Integer/parseInt "00010000" 2) ; select buttons
555 0x00 ;D352 ; input-number
557 ;; select directional pad; store low bits in B
559 0xFA ;D353 ; load (D350) into A
560 0x50 ;D354 -->
561 0xD3 ;D355 --> D350
563 0xEA ;D356 ; load (A), which is
564 0x00 ;D357 --> ; 00010000, into FF00
565 0xFF ;D358 --> FF00
567 0x06 ;D359
568 ;D35A
569 (Integer/parseInt "11110000" 2) ; "11110000" -> B
570 0xFA ;D35B ; (FF00) -> A
571 0x00 ;D35C
572 0xFF ;D35D
574 0xCB ;D35E ; swap nybbles on A
575 0x37 ;D35F
576 0xA0 ;D360 ; (AND A B) -> A
577 0x47 ;D361 ; A -> B
579 ;; select buttons; store bottom bits in C
581 0xFA ;D362 ; load (D351) into A
582 0x51 ;D363 -->
583 0xD3 ;D364 --> D351
585 0xEA ;D365 ; load (A), which is
586 0x00 ;D366 --> ; 00001000, into FF00
587 0xFF ;D367 --> FF00
589 0x0E ;D368
590 ;D369
591 (Integer/parseInt "00001111" 2) ; "00001111" -> C
593 0xFA ;D36A ; (FF00) -> A
594 0x00 ;D36B
595 0xFF ;D36C
597 0xA1 ;D36D ; (AND A C) -> A
598 0x4F ;D36E ; A -> C
600 ;; combine the B and C registers into the input number
601 0x79 ;D36F ; C -> A
602 0xB0 ;D370 ; (OR A B) -> A
603 0x2F ;D371 ; negate A
605 0xEA ;D372 ; store A into input-number
606 0x52 ;D373
607 0xD3 ;D374
609 0x00 ;D375
610 0x00 ;D376
611 0x00 ;D377
612 0x00 ;D378
613 0x00 ;D379
614 0x00 ;D37A
615 0x00 ;D37B ; these are here because
616 0x00 ;D37C ; I messed up :(
617 0x00 ;D37D
618 0x00 ;D37E
619 0x00 ;D37F
621 ;; beginning of main state machine
622 0x18 ;D380 ; Declaration of variables
623 0x05 ;D381 ; 5 variables:
624 0x00 ;D382 ; current-mode
625 0x00 ;D383 ; bytes-to-write
626 0x00 ;D384 ; start-point
627 0x00 ;D385 ; unused
628 0x00 ;D386 ; unused
631 ;; banch on current mode
632 0xFA ;D387 ; load current-mode (0xD382)
633 0x82 ;D388 ; into A
634 0xD3 ;D389
635 0x00 ;D38A
638 ;; GOTO Mode 0 (input-mode) if current-mode is 0
639 0xFE ;D38B
640 0x00 ;D38C ; compare A with 0x00
642 0xCA ;D38D ; goto Mode 0 if A == 0
643 0xA8 ;D38E
644 0xD3 ;D38F
646 ;; GOTO Mode 1 (set-length) if current-mode is 1
647 0xFE ;D390
648 0x01 ;D391 ; compare A with 0x01
650 0xCA ;D392
651 0xB1 ;D393
652 0xD3 ;D394 ; goto Mode 1 if A == 1
654 ;; GOTO Mode 2 (set-start-point) if current mode is 2
655 0xFE ;D395
656 0x02 ;D396 ; compare A with 0x02
658 0xCA ;D397
659 0xBF ;D398
660 0xD3 ;D399 ; goto Mode 2 if A == 2
662 0x00 ;D39A
663 0x00 ;D39B
664 0x00 ;D39C
665 0x00 ;D39D
666 0x00 ;D39E
667 0x00 ;D39F
668 0x00 ;D3A0
669 0x00 ;D3A1
670 0x00 ;D3A2
671 0x00 ;D3A3
672 0x00 ;D3A4
673 ;; End of Mode checking, goto beginning
674 0xC3 ;D3A5
675 0x1D ;D3A6
676 0xD3 ;D3A7
679 ;; Mode 0 -- input-mode mode
680 ;; means that we are waiting for a mode, so set the mode to
681 ;; whatever is currently in input-number. If nothing is
682 ;; entered, then the program stays in input-mode mode
684 ;; set current-mode to input-number
685 0xFA ;D3A8 ; load input-number (0xD352)
686 0x52 ;D3A9 ; into A
687 0xD3 ;D3AA
689 0xEA ;D3AB ; load A into current-mode
690 0x82 ;D3AC ; (0xD382)
691 0xD3 ;D3AD
693 0xC3 ;D3AE ; go back to beginning
694 0x1D ;D3AF
695 0xD3 ;D3B0
696 ;; End Mode 0
699 ;; Mode 1 -- set-length mode
700 ;; This is the header for writing things to memory.
701 ;; User specifies the number of bytes to write.
702 ;; Mode is auto advanced to Mode 2 after this mode
703 ;; completes.
705 ;; Set bytes left to write to input-number;
706 ;; set current-mode to 0x02.
707 0xFA ;D3B1 ; load input-number (0xD352)
708 0x52 ;D3B2 ; into A
709 0xD3 ;D3B3
711 0xEA ;D3B4 ; load A into bytes-left-to-write
712 0x83 ;D3B5 ; (0xD383)
713 0xD3 ;D3B6
715 0x3E ;D3B7 ; load 0x02 into A.
716 0x02 ;D3B8
718 0xEA ;D3B9 ; load A to current-mode
719 0x82 ;D3BA ; advancing from Mode 1 to
720 0xD3 ;D3BB ; Mode 2
722 0xC3 ;D3BC ; go back to beginning
723 0x1D ;D3BD
724 0xD3 ;D3BE
725 ;; End Mode 1
728 ;; Mode 2 -- set start-point mode
729 ;; Final part of the header for writing things to memory.
730 ;; User specifies the start location in RAM to which
731 ;; data will be written.
732 ;; Mode is auto advanced to Mode 3 after this mode completes.
734 ;; Set start-point to input-number;
735 ;; set current mode to 0x03.
736 0xFA ;D3BF ; load input-number (0xD352)
737 0x52 ;D3C0 ; into A
738 0xD3 ;D3C1
740 0xEA ;D3C2 ; load A into start-point
741 0x84 ;D3C3 ; (0xD384)
742 0xD3 ;D3C4
744 0x3E ;D3C5 ; load 0x03 into A.
745 0x03 ;D3C6
747 0xEA ;D3C7 ; load A to current-mode,
748 0x82 ;D3C8 ; advancing from Mode 2 to
749 0xD3 ;D3C9 ; Mode 3.
751 0xC3 ;D3CA ; go back to beginning
752 0x1D ;D3CB
753 0xD3 ;D3CC
754 ;;End Mode 2
756 0x00 ;D3CD
757 0x00 ;D3CE
758 0x00 ;D3CF
759 0x00 ;D3D0
760 0x00 ;D3D1
761 0x00 ;D3D2
762 0x00 ;D3D3
763 0x00 ;D3D4
764 0x00 ;D3D5
765 0x00 ;D3D6
767 ;; Mode 3 -- write bytes mode
768 ;; This is where RAM manipulation happens.
769 ;; User supplies bytes every frame, which are written
770 ;; sequentially to
775 0xC3 ; ; Complete Loop
776 0x1D ;
777 0xD3 ;
781 ])
785 (def frame-count 0xD31F)
786 (def input 0xD352)
787 (def current-mode 0xD382)
788 (def bytes-to-write 0xD383)
789 (def start-point 0xD384)
792 (defn write-memory []
793 (-> (tick (mid-game))
794 (IE! 0) ; disable interrupts
795 (inject-item-assembly (write-memory-assembly))))
797 (defn test-write-memory []
798 (set-state! (write-memory))
799 (dorun
800 (dotimes [_ 5000]
801 (view-memory (step @current-state) current-mode))))
803 (def bytes-to-write 0xD383)
804 (def start-point 0xD384)
806 (defn test-mode-2 []
807 (->
808 (write-memory)
809 (view-memory frame-count)
810 (step)
811 (step [:a])
812 (step [:b])
813 (step [:start])
814 (step [])
815 (view-memory frame-count)))
817 (defn test-mode-2 []
818 (->
819 (write-memory)
820 (view-memory current-mode)
821 (step [])
822 (step [])
823 (step [])
824 (#(do (println "after three steps") %))
825 (view-memory current-mode)
826 (step [:a])
827 (#(do (println "step with [:a]") %))
828 (view-memory current-mode)
829 (view-memory bytes-to-write)
830 (view-memory start-point)
831 (#(do (println "step with [:u :d :l :r]")%))
832 (step [:u :d])
833 (view-memory current-mode)
834 (view-memory bytes-to-write)
835 (view-memory start-point)
836 (#(do (println "step with [:u :d]")%))
837 (step [:u :d])
838 (view-memory current-mode)
839 (view-memory bytes-to-write)
840 (view-memory start-point)
842 ))