rlm@105
|
1 (ns com.aurellem.assembly
|
rlm@105
|
2 (:use (com.aurellem gb-driver vbm title items))
|
rlm@105
|
3 (:import [com.aurellem.gb_driver SaveState]))
|
rlm@105
|
4
|
rlm@106
|
5 (defn mid-game []
|
rlm@106
|
6 (read-state "mid-game"))
|
rlm@105
|
7
|
rlm@105
|
8 (defn inject-assembly
|
rlm@107
|
9 ([^SaveState state
|
rlm@105
|
10 program-counter registers
|
rlm@105
|
11 assembly-code]
|
rlm@105
|
12 (let [scratch-memory (memory state)]
|
rlm@105
|
13 ;; inject assembly code
|
rlm@105
|
14 (dorun (map (fn [index val]
|
rlm@105
|
15 (aset scratch-memory index val))
|
rlm@105
|
16 (range program-counter
|
rlm@105
|
17 (+ program-counter (count assembly-code)))
|
rlm@105
|
18 assembly-code))
|
rlm@106
|
19 (-> state
|
rlm@106
|
20 (write-memory! scratch-memory)
|
rlm@106
|
21 (write-registers! registers)
|
rlm@112
|
22 (PC! program-counter)))))
|
rlm@105
|
23
|
rlm@105
|
24 (defn inject-item-assembly
|
rlm@105
|
25 ([^SaveState state assembly-code]
|
rlm@105
|
26 (inject-assembly state (inc item-list-start)
|
rlm@105
|
27 (registers state)
|
rlm@105
|
28 assembly-code))
|
rlm@105
|
29 ([assembly-code]
|
rlm@105
|
30 (inject-item-assembly @current-state assembly-code)))
|
rlm@105
|
31
|
rlm@105
|
32 (defn info
|
rlm@105
|
33 ([^SaveState state]
|
rlm@107
|
34 (println (format "PC: 0x%04X" (PC state)))
|
rlm@106
|
35 (println "Instruction:"
|
rlm@106
|
36 (format "0x%02X" (aget (memory state) (PC state))))
|
rlm@105
|
37 state))
|
rlm@105
|
38
|
rlm@107
|
39 (defn print-interrupt
|
rlm@107
|
40 [^SaveState state]
|
rlm@107
|
41 (println (format "IE: %d" (IE state)))
|
rlm@107
|
42 state)
|
rlm@107
|
43
|
rlm@118
|
44 (defn print-listing [state begin end]
|
rlm@118
|
45 (dorun (map
|
rlm@118
|
46 (fn [opcode line]
|
rlm@118
|
47 (println (format "0x%04X: 0x%02X" line opcode)))
|
rlm@118
|
48 (subvec (vec (memory state)) begin end)
|
rlm@118
|
49 (range begin end)))
|
rlm@118
|
50 state)
|
rlm@118
|
51
|
rlm@105
|
52 (defn run-assembly
|
rlm@105
|
53 ([info-fn assembly n]
|
rlm@105
|
54 (let [final-state
|
rlm@105
|
55 (reduce (fn [state _]
|
rlm@105
|
56 (tick (info-fn state)))
|
rlm@107
|
57 (inject-item-assembly
|
rlm@107
|
58 (mid-game) assembly)
|
rlm@105
|
59 (range n))]
|
rlm@105
|
60 final-state))
|
rlm@105
|
61 ([assembly n]
|
rlm@105
|
62 (run-assembly info assembly n)))
|
rlm@107
|
63
|
rlm@107
|
64 (def buttons-port 0xFF00)
|
rlm@107
|
65
|
rlm@107
|
66 (defn A [state]
|
rlm@107
|
67 (bit-shift-right (bit-and 0x0000FF00 (AF state)) 8))
|
rlm@107
|
68
|
rlm@128
|
69 (defn B [state]
|
rlm@128
|
70 (bit-shift-right (bit-and 0x0000FF00 (BC state)) 8))
|
rlm@128
|
71
|
rlm@128
|
72 (defn C [state]
|
rlm@128
|
73 (bit-and 0xFF (BC state)))
|
rlm@128
|
74
|
rlm@110
|
75 (defn binary-str [num]
|
rlm@110
|
76 (format "%08d"
|
rlm@110
|
77 (Integer/parseInt
|
rlm@110
|
78 (Integer/toBinaryString num) 10)))
|
rlm@110
|
79
|
rlm@110
|
80 (defn view-register [state name reg-fn]
|
rlm@110
|
81 (println (format "%s: %s" name
|
rlm@110
|
82 (binary-str (reg-fn state))))
|
rlm@110
|
83 state)
|
rlm@110
|
84
|
rlm@107
|
85 (defn view-memory [state mem]
|
rlm@110
|
86 (println (format "mem 0x%04X = %s" mem
|
rlm@110
|
87 (binary-str (aget (memory state) mem))))
|
rlm@107
|
88 state)
|
rlm@107
|
89
|
rlm@118
|
90 (defn trace [state]
|
rlm@124
|
91 (loop [program-counters [(first (registers @current-state)) ]
|
rlm@124
|
92 opcodes [(aget (memory @current-state) (PC @current-state))]]
|
rlm@118
|
93 (let [frame-boundary?
|
rlm@118
|
94 (com.aurellem.gb.Gb/tick)]
|
rlm@118
|
95 (if frame-boundary?
|
rlm@118
|
96 [program-counters opcodes]
|
rlm@118
|
97 (recur
|
rlm@118
|
98 (conj program-counters
|
rlm@118
|
99 (first (registers @current-state)))
|
rlm@118
|
100 (conj opcodes
|
rlm@118
|
101 (aget (memory @current-state)
|
rlm@118
|
102 (PC @current-state))))))))
|
rlm@124
|
103
|
rlm@124
|
104 (defn print-trace [state n]
|
rlm@124
|
105 (let [[program-counters opcodes] (trace state)]
|
rlm@124
|
106 (dorun (map (fn [pc op] (println (format "%04X: 0x%02X" pc op)))
|
rlm@124
|
107 (take n program-counters)
|
rlm@124
|
108 (take n opcodes)))))
|
rlm@124
|
109
|
rlm@118
|
110 (defn good-trace []
|
rlm@118
|
111 (-> (mid-game) (tick) (IE! 0)
|
rlm@118
|
112 (set-inv-mem [0x00 0x00 0X00 0x00])
|
rlm@118
|
113 (PC! item-list-start)(print-interrupt)
|
rlm@118
|
114 (info) (tick) (info) (tick) (info)))
|
rlm@118
|
115
|
rlm@113
|
116 (defn read-down-button []
|
rlm@110
|
117 (-> (tick (mid-game))
|
rlm@110
|
118 (IE! 0) ; disable interrupts
|
rlm@110
|
119 (inject-item-assembly
|
rlm@118
|
120 ;; write 00010000 to 0xFF00 to select joypad
|
rlm@118
|
121 [0x18 ;D31D ; jump over
|
rlm@118
|
122 0x01 ;D31E ; the next 8 bits
|
rlm@118
|
123 ;D31F
|
rlm@118
|
124 (Integer/parseInt "00100000" 2) ; data section
|
rlm@118
|
125
|
rlm@118
|
126 0xFA ;D320 ; load (D31F) into A
|
rlm@118
|
127 0x1F ;D321 -->
|
rlm@118
|
128 0xD3 ;D322 --> D31F
|
rlm@107
|
129
|
rlm@118
|
130 0xEA ;D323 ; load (A), which is
|
rlm@118
|
131 0x00 ;D324 --> ; 00010000, into FF00
|
rlm@118
|
132 0xFF ;D325 --> FF00
|
rlm@118
|
133
|
rlm@118
|
134 0x18 ;D326 ; this is the place where
|
rlm@118
|
135 0x01 ;D327 ; we will store whether
|
rlm@118
|
136 0x00 ;D328 ; "down" is pressed.
|
rlm@107
|
137
|
rlm@118
|
138 0xFA ;D329 ; (FF00) -> A
|
rlm@118
|
139 0x00 ;D32A
|
rlm@118
|
140 0xFF ;D32B
|
rlm@110
|
141
|
rlm@118
|
142 0xCB ;D32C ; Test whether "down"
|
rlm@118
|
143 0x5F ;D32D ; is pressed.
|
rlm@111
|
144
|
rlm@118
|
145 0x28 ;D32E ; if down is pressed,
|
rlm@118
|
146 0x03 ;D32F ; skip the next section
|
rlm@118
|
147 ; of code.
|
rlm@118
|
148 ;; down-is-not-pressed
|
rlm@118
|
149 0xC3 ;D330
|
rlm@118
|
150 0x1D ;D331 ; return to beginning
|
rlm@118
|
151 0xD3 ;D332
|
rlm@118
|
152
|
rlm@118
|
153 ;; down-is-pressed
|
rlm@118
|
154 0xEA ;D334 ; write A to D328 if
|
rlm@118
|
155 0x28 ;D335 ; "down" was pressed
|
rlm@118
|
156 0xD3 ;D336
|
rlm@111
|
157
|
rlm@118
|
158 0xC3 ;D330
|
rlm@118
|
159 0x1D ;D331 ; return to beginning
|
rlm@118
|
160 0xD3 ;D332
|
rlm@118
|
161 ])))
|
rlm@111
|
162
|
rlm@118
|
163 (defn test-read-down []
|
rlm@118
|
164 (= (view-memory (step (step (read-down-button) [:d])) 0xD328)
|
rlm@118
|
165 (view-memory (step (step (read-down-button))) 0xD328)))
|
rlm@113
|
166
|
rlm@113
|
167 (defn count-frames []
|
rlm@113
|
168 (-> (tick (mid-game))
|
rlm@113
|
169 (IE! 0) ; disable interrupts
|
rlm@113
|
170 (inject-item-assembly
|
rlm@113
|
171 [0x18 ;D31D ; jump over
|
rlm@113
|
172 0x02 ;D31E ; the next 2 bytes
|
rlm@113
|
173 0x00 ;D31F ; frame-count
|
rlm@113
|
174 0x00 ;D320 ; v-blank-prev
|
rlm@113
|
175
|
rlm@113
|
176 0xFA ;D321
|
rlm@113
|
177 0x41 ;D322 ; load (FF41) into A
|
rlm@113
|
178 0xFF ;D323 ; this contains mode flags
|
rlm@113
|
179
|
rlm@113
|
180 ;; if we're in v-blank, the bit-1 is 0
|
rlm@113
|
181 ;; and bit-2 is 1 Otherwise, it is not v-blank.
|
rlm@113
|
182 0xCB ;D324 ; test bit-1 of A
|
rlm@113
|
183 0x4F ;D325
|
rlm@113
|
184
|
rlm@113
|
185 0xC2 ;D326 ; if bit-1 is not 0
|
rlm@115
|
186 0x44 ;D327 ; GOTO not-v-blank
|
rlm@113
|
187 0xD3 ;D328
|
rlm@113
|
188
|
rlm@113
|
189 0xCB ;D329 ; test bit-0 of A
|
rlm@113
|
190 0x47 ;D32A
|
rlm@113
|
191
|
rlm@113
|
192 0xCA ;D32B ; if bit-0 is not 1
|
rlm@115
|
193 0x44 ;D32C ; GOTO not-v-blank
|
rlm@113
|
194 0xD3 ;D32D
|
rlm@114
|
195 ;;; in v-blank mode
|
rlm@113
|
196 ;; if v-blank-prev was 0,
|
rlm@113
|
197 ;; increment frame-count
|
rlm@113
|
198
|
rlm@113
|
199 0xFA ;D32E ; load v-blank-prev to A
|
rlm@113
|
200 0x20 ;D32F
|
rlm@113
|
201 0xD3 ;D330
|
rlm@113
|
202
|
rlm@113
|
203 0xCB ;D331
|
rlm@113
|
204 0x47 ;D332 ; test bit-0 of A
|
rlm@113
|
205
|
rlm@113
|
206 0x20 ;D333 ; skip next section
|
rlm@113
|
207 0x07 ;D334 ; if v-blank-prev was not zero
|
rlm@113
|
208
|
rlm@113
|
209 ;; v-blank was 0, increment frame-count
|
rlm@113
|
210 0xFA ;D335 ; load frame-count into A
|
rlm@113
|
211 0x1F ;D336
|
rlm@113
|
212 0xD3 ;D337
|
rlm@113
|
213
|
rlm@113
|
214 0x3C ;D338 ; inc A
|
rlm@113
|
215
|
rlm@113
|
216 0xEA ;D339 ; load A into frame-count
|
rlm@113
|
217 0x1F ;D33A
|
rlm@113
|
218 0xD3 ;D33B
|
rlm@113
|
219
|
rlm@114
|
220 ;; set v-blank-prev to 1
|
rlm@113
|
221 0x3E ;D33C ; load 1 into A
|
rlm@113
|
222 0x01 ;D33D
|
rlm@113
|
223
|
rlm@113
|
224 0xEA ;D33E ; load A into v-blank-prev
|
rlm@113
|
225 0x20 ;D33F
|
rlm@113
|
226 0xD3 ;D340
|
rlm@113
|
227
|
rlm@115
|
228 0xC3 ;D341 ; return to beginning
|
rlm@115
|
229 0x1D ;D342
|
rlm@115
|
230 0xD3 ;D343
|
rlm@113
|
231
|
rlm@114
|
232 ;;; not in v-blank mode
|
rlm@114
|
233 ;; set v-blank-prev to 0
|
rlm@115
|
234 0x3E ;D344 ; load 0 into A
|
rlm@115
|
235 0x00 ;D345
|
rlm@113
|
236
|
rlm@115
|
237 0xEA ;D346 ; load A into v-blank-prev
|
rlm@115
|
238 0x20 ;D347
|
rlm@115
|
239 0xD3 ;D348
|
rlm@115
|
240
|
rlm@115
|
241 0xC3 ;D349 ; return to beginning
|
rlm@115
|
242 0x1D ;D34A
|
rlm@115
|
243 0xD3 ;D34B
|
rlm@113
|
244 ])))
|
rlm@113
|
245
|
rlm@114
|
246 (defn step-count-frames []
|
rlm@113
|
247 (-> (read-down-button)
|
rlm@110
|
248 (info)
|
rlm@110
|
249 (tick) ;; skip over data section
|
rlm@110
|
250 (info)
|
rlm@110
|
251 (view-register "Register A" A)
|
rlm@110
|
252 (tick) ;; load-data into A
|
rlm@110
|
253 (view-register "Register A" A)
|
rlm@110
|
254 (info)
|
rlm@110
|
255 (view-memory 0xFF00)
|
rlm@110
|
256 (tick) ;; load A into 0xFF00
|
rlm@110
|
257 (view-memory 0xFF00)
|
rlm@111
|
258 (info)
|
rlm@111
|
259 (tick)
|
rlm@111
|
260 (info)
|
rlm@111
|
261 (tick)
|
rlm@111
|
262 (info)
|
rlm@111
|
263 (tick)
|
rlm@111
|
264 (info)
|
rlm@111
|
265 (tick)
|
rlm@111
|
266 (info)
|
rlm@111
|
267 (tick)
|
rlm@111
|
268 (info)
|
rlm@111
|
269 (tick)
|
rlm@111
|
270 (print-inventory)))
|
rlm@111
|
271
|
rlm@115
|
272 (defn test-count-frames []
|
rlm@115
|
273 (= 255 (aget (memory ((apply comp (repeat 255 step))
|
rlm@115
|
274 (count-frames)))
|
rlm@115
|
275 0xD31F)))
|
rlm@115
|
276
|
rlm@115
|
277 ;; specs for main bootstrap program
|
rlm@115
|
278 ;; starts in "mode-select" mode
|
rlm@115
|
279 ;; Each button press takes place in a single frame.
|
rlm@115
|
280 ;; mode-select-mode takes one of the main buttons
|
rlm@115
|
281 ;; which selects one of up to eight modes
|
rlm@115
|
282 ;; mode 1 activated by the "A" button
|
rlm@115
|
283 ;; the next two button presses indicates the start
|
rlm@115
|
284 ;; memory location which to which the bootstrap
|
rlm@115
|
285 ;; program will write.
|
rlm@115
|
286 ;; This is done by using each of the eight buttons to
|
rlm@115
|
287 ;; spell out an 8 bit number. The order of buttons is
|
rlm@116
|
288 ;; [:d :u :l :r :start :select :b :a]
|
rlm@116
|
289 ;; [:a :start :l] --> 00101001
|
rlm@114
|
290
|
rlm@115
|
291 ;; the next button press determines how many bytes are to be
|
rlm@115
|
292 ;; written, starting at the start position.
|
rlm@114
|
293
|
rlm@115
|
294 ;; then, the actual bytes are entered and are written to the
|
rlm@115
|
295 ;; start address in sequence.
|
rlm@114
|
296
|
rlm@118
|
297 (defn input-number-assembly []
|
rlm@118
|
298 [0x18 ;D31D ; jump over
|
rlm@118
|
299 0x02 ;D31E ; the next 2 bytes
|
rlm@118
|
300 0x00 ;D31F ; frame-count
|
rlm@118
|
301 0x00 ;D320 ; v-blank-prev
|
rlm@118
|
302
|
rlm@118
|
303 0xFA ;D321
|
rlm@118
|
304 0x41 ;D322 ; load (FF41) into A
|
rlm@118
|
305 0xFF ;D323 ; this contains mode flags
|
rlm@118
|
306
|
rlm@118
|
307 ;; if we're in v-blank, the bit-1 is 0
|
rlm@118
|
308 ;; and bit-2 is 1 Otherwise, it is not v-blank.
|
rlm@118
|
309 0xCB ;D324 ; test bit-1 of A
|
rlm@118
|
310 0x4F ;D325
|
rlm@114
|
311
|
rlm@118
|
312 0xC2 ;D326 ; if bit-1 is not 0
|
rlm@118
|
313 0x44 ;D327 ; GOTO not-v-blank
|
rlm@118
|
314 0xD3 ;D328
|
rlm@118
|
315
|
rlm@118
|
316 0xCB ;D329 ; test bit-0 of A
|
rlm@118
|
317 0x47 ;D32A
|
rlm@118
|
318
|
rlm@118
|
319 0xCA ;D32B ; if bit-0 is not 1
|
rlm@118
|
320 0x44 ;D32C ; GOTO not-v-blank
|
rlm@118
|
321 0xD3 ;D32D
|
rlm@118
|
322
|
rlm@118
|
323 ;;; in v-blank mode
|
rlm@118
|
324
|
rlm@118
|
325 ;; if v-blank-prev was 0,
|
rlm@118
|
326 ;; increment frame-count
|
rlm@118
|
327
|
rlm@118
|
328 0xFA ;D32E ; load v-blank-prev to A
|
rlm@118
|
329 0x20 ;D32F
|
rlm@118
|
330 0xD3 ;D330
|
rlm@118
|
331
|
rlm@118
|
332 0xCB ;D331
|
rlm@118
|
333 0x47 ;D332 ; test bit-0 of A
|
rlm@118
|
334
|
rlm@118
|
335 0x20 ;D333 ; skip next section
|
rlm@118
|
336 0x07 ;D334 ; if v-blank-prev was not zero
|
rlm@118
|
337
|
rlm@118
|
338 ;; v-blank was 0, increment frame-count
|
rlm@118
|
339 0xFA ;D335 ; load frame-count into A
|
rlm@118
|
340 0x1F ;D336
|
rlm@118
|
341 0xD3 ;D337
|
rlm@118
|
342
|
rlm@118
|
343 0x3C ;D338 ; inc A
|
rlm@118
|
344
|
rlm@118
|
345 0xEA ;D339 ; load A into frame-count
|
rlm@118
|
346 0x1F ;D33A
|
rlm@118
|
347 0xD3 ;D33B
|
rlm@118
|
348
|
rlm@118
|
349 ;; set v-blank-prev to 1
|
rlm@118
|
350 0x3E ;D33C ; load 1 into A
|
rlm@118
|
351 0x01 ;D33D
|
rlm@118
|
352
|
rlm@118
|
353 0xEA ;D33E ; load A into v-blank-prev
|
rlm@118
|
354 0x20 ;D33F
|
rlm@118
|
355 0xD3 ;D340
|
rlm@118
|
356
|
rlm@118
|
357 0xC3 ;D341 ; GOTO input handling code
|
rlm@118
|
358 0x4E ;D342
|
rlm@118
|
359 0xD3 ;D343
|
rlm@118
|
360
|
rlm@118
|
361 ;;; not in v-blank mode
|
rlm@118
|
362 ;; set v-blank-prev to 0
|
rlm@118
|
363 0x3E ;D344 ; load 0 into A
|
rlm@118
|
364 0x00 ;D345
|
rlm@118
|
365
|
rlm@118
|
366 0xEA ;D346 ; load A into v-blank-prev
|
rlm@118
|
367 0x20 ;D347
|
rlm@118
|
368 0xD3 ;D348
|
rlm@118
|
369
|
rlm@118
|
370 0xC3 ;D349 ; return to beginning
|
rlm@118
|
371 0x1D ;D34A
|
rlm@118
|
372 0xD3 ;D34B
|
rlm@118
|
373
|
rlm@118
|
374 0x00 ;D34C ; these are here
|
rlm@118
|
375 0x00 ;D34D ; for glue
|
rlm@118
|
376
|
rlm@118
|
377
|
rlm@118
|
378 ;;; calculate input number based on button presses
|
rlm@118
|
379 0x18 ;D34E ; skip next 3 bytes
|
rlm@118
|
380 0x03 ;D34F
|
rlm@118
|
381 ;D350
|
rlm@118
|
382 (Integer/parseInt "00100000" 2) ; select directional pad
|
rlm@118
|
383 ;D351
|
rlm@118
|
384 (Integer/parseInt "00010000" 2) ; select buttons
|
rlm@118
|
385 0x00 ;D352 ; input-number
|
rlm@118
|
386
|
rlm@118
|
387 ;; select directional pad, store low bits in B
|
rlm@118
|
388
|
rlm@118
|
389 0xFA ;D353 ; load (D350) into A
|
rlm@118
|
390 0x50 ;D354 -->
|
rlm@118
|
391 0xD3 ;D355 --> D31F
|
rlm@118
|
392
|
ocsenave@135
|
393 0xEA ;D356 ; load A, which is
|
rlm@118
|
394 0x00 ;D357 --> ; 00010000, into FF00
|
rlm@118
|
395 0xFF ;D358 --> FF00
|
rlm@118
|
396
|
rlm@118
|
397 0x06 ;D359
|
rlm@118
|
398 ;D35A
|
rlm@118
|
399 (Integer/parseInt "11110000" 2) ; "11110000" -> B
|
rlm@118
|
400 0xFA ;D35B ; (FF00) -> A
|
rlm@118
|
401 0x00 ;D35C
|
rlm@118
|
402 0xFF ;D35D
|
rlm@118
|
403
|
rlm@118
|
404 0xCB ;D35E ; swap nybbles on A
|
rlm@118
|
405 0x37 ;D35F
|
rlm@118
|
406 0xA0 ;D360 ; (AND A B) -> A
|
rlm@118
|
407 0x47 ;D361 ; A -> B
|
rlm@118
|
408
|
rlm@118
|
409 ;; select buttons store bottom bits in C
|
rlm@118
|
410
|
rlm@118
|
411 0xFA ; ; load (D351) into A
|
rlm@118
|
412 0x51 ; -->
|
rlm@118
|
413 0xD3 ; --> D31F
|
rlm@118
|
414
|
rlm@118
|
415 0xEA ; ; load (A), which is
|
rlm@118
|
416 0x00 ; --> ; 00001000, into FF00
|
rlm@118
|
417 0xFF ; --> FF00
|
rlm@118
|
418
|
rlm@118
|
419 0x0E ;
|
rlm@118
|
420 (Integer/parseInt "00001111" 2) ; "00001111" -> C
|
rlm@118
|
421
|
rlm@118
|
422 0xFA ; ; (FF00) -> A
|
rlm@118
|
423 0x00 ;
|
rlm@118
|
424 0xFF ;
|
rlm@118
|
425
|
rlm@118
|
426 0xA1 ; ; (AND A C) -> A
|
rlm@118
|
427 0x4F ; ; A -> C
|
rlm@118
|
428
|
rlm@118
|
429 ;; combine the B and C registers into the input number
|
rlm@118
|
430 0x79 ; ; C -> A
|
rlm@118
|
431 0xB0 ; ; (OR A B) -> A
|
rlm@118
|
432 0x2F ; ; negate A
|
rlm@118
|
433
|
rlm@118
|
434 0xEA ; ; store A into input-number
|
rlm@118
|
435 0x52 ;
|
rlm@118
|
436 0xD3 ;
|
rlm@118
|
437
|
rlm@118
|
438 0xC3 ; ; return to beginning
|
rlm@118
|
439 0x1D ;
|
rlm@118
|
440 0xD3 ;
|
rlm@118
|
441 ])
|
rlm@114
|
442
|
rlm@128
|
443
|
rlm@128
|
444 (defn print-pc [state]
|
rlm@128
|
445 (println (format "PC: 0x%04X" (PC state)))
|
rlm@128
|
446 state)
|
rlm@128
|
447
|
rlm@128
|
448 (defn print-op [state]
|
rlm@128
|
449 (println (format "OP: 0x%02X" (aget (memory state) (PC state))))
|
rlm@128
|
450 state)
|
rlm@128
|
451
|
rlm@128
|
452 (defn d-tick
|
rlm@128
|
453 ([state]
|
rlm@128
|
454 (-> state print-pc print-op tick)))
|
rlm@128
|
455
|
rlm@115
|
456 (defn input-number []
|
rlm@115
|
457 (-> (tick (mid-game))
|
rlm@115
|
458 (IE! 0) ; disable interrupts
|
rlm@118
|
459 (inject-item-assembly (input-number-assembly))))
|
rlm@115
|
460
|
rlm@117
|
461 (defn test-input-number
|
rlm@117
|
462 "Input freestyle buttons and observe the effects at the repl."
|
rlm@117
|
463 []
|
rlm@117
|
464 (set-state! (input-number))
|
rlm@117
|
465 (dotimes [_ 90000] (step (view-memory @current-state 0xD352))))
|
rlm@115
|
466
|
rlm@128
|
467
|
rlm@128
|
468
|
rlm@128
|
469
|
ocsenave@135
|
470
|
ocsenave@135
|
471
|
ocsenave@135
|
472
|
ocsenave@135
|
473
|
ocsenave@135
|
474
|
ocsenave@135
|
475
|
ocsenave@135
|
476
|
ocsenave@135
|
477
|
ocsenave@135
|
478
|
ocsenave@135
|
479
|
ocsenave@135
|
480
|
ocsenave@135
|
481
|
ocsenave@135
|
482
|
ocsenave@135
|
483
|
ocsenave@135
|
484
|
ocsenave@135
|
485
|
ocsenave@135
|
486
|
ocsenave@135
|
487
|
ocsenave@135
|
488
|
ocsenave@135
|
489
|
ocsenave@135
|
490
|
ocsenave@135
|
491
|
ocsenave@135
|
492
|
ocsenave@135
|
493
|
ocsenave@135
|
494
|
ocsenave@136
|
495 (defn write-memory-assembly*
|
ocsenave@136
|
496 "Currently, grabs input from the user each frame."
|
ocsenave@136
|
497 []
|
rlm@128
|
498 [
|
ocsenave@135
|
499 ;; --------- FRAME METRONOME
|
ocsenave@138
|
500 0x18 ;; jump ahead to cleanup. first time only.
|
ocsenave@138
|
501 0x40 ;; v-blank-prev [D31E]
|
rlm@128
|
502
|
ocsenave@138
|
503 0xFA ;; load modes into A [D31F]
|
rlm@128
|
504 0x41
|
rlm@128
|
505 0xFF
|
ocsenave@135
|
506
|
ocsenave@135
|
507 0x47 ;; A -> B
|
ocsenave@135
|
508 0xCB ;; rotate A
|
rlm@128
|
509 0x2F
|
ocsenave@135
|
510 0x2F ;; invert A
|
rlm@128
|
511
|
rlm@128
|
512 0xA0
|
ocsenave@135
|
513 0x47 ;; now B_0 contains (VB==1)
|
rlm@128
|
514
|
rlm@128
|
515 0xFA ;; load v-blank-prev
|
ocsenave@138
|
516 0x1E
|
rlm@128
|
517 0xD3
|
rlm@128
|
518
|
ocsenave@135
|
519 0x2F ;; complement v-blank-prev
|
ocsenave@135
|
520
|
ocsenave@135
|
521 0xA0 ;; A & B --> A
|
ocsenave@135
|
522 0x4F ;; now C_0 contains increment?
|
ocsenave@135
|
523
|
rlm@128
|
524
|
rlm@128
|
525 0x78 ;; B->A
|
rlm@128
|
526 0xEA ;; spit A --> vbprev
|
ocsenave@138
|
527 0x1E
|
rlm@128
|
528 0xD3
|
rlm@128
|
529
|
ocsenave@136
|
530 0xCB ;test C_0
|
ocsenave@136
|
531 0x41
|
ocsenave@136
|
532 0x20 ; JUMP ahead to button input if nonzero
|
ocsenave@138
|
533 0x02
|
ocsenave@138
|
534 0x18 ; JUMP back to frame metronome (D31F)
|
ocsenave@138
|
535 0xE6 ; todo: verify this jump length
|
ocsenave@135
|
536
|
ocsenave@135
|
537 ;; -------- GET BUTTON INPUT
|
ocsenave@137
|
538
|
ocsenave@137
|
539 ;; btw, C_0 is now 1
|
ocsenave@135
|
540 ;; prepare to select bits
|
ocsenave@135
|
541
|
ocsenave@137
|
542 0x06 ;; load 0x00 into B
|
ocsenave@138
|
543 0x00 ;; to initialize for "OR" loop
|
ocsenave@137
|
544
|
ocsenave@137
|
545 0x3E ;; load 0x20 into A, to measure dpad
|
ocsenave@135
|
546 0x20
|
ocsenave@135
|
547
|
ocsenave@135
|
548
|
ocsenave@138
|
549 0xE0 ;; load A into [FF00] ;; start of OR loop [D33C]
|
ocsenave@135
|
550 0x00
|
ocsenave@137
|
551
|
ocsenave@137
|
552 0xF0 ;; load A from [FF00]
|
ocsenave@135
|
553 0x00
|
ocsenave@135
|
554
|
ocsenave@135
|
555 0xE6 ;; bitmask 00001111
|
ocsenave@135
|
556 0x0F
|
ocsenave@135
|
557
|
ocsenave@135
|
558 0xB0 ;; A or B --> A
|
ocsenave@135
|
559 0xCB
|
ocsenave@135
|
560 0x41 ;; test bit 0 of C
|
ocsenave@137
|
561 0x28 ;; JUMP forward if 0
|
ocsenave@135
|
562 0x08
|
ocsenave@135
|
563
|
ocsenave@135
|
564 0x47 ;; A -> B
|
ocsenave@135
|
565 0xCB ;; swap B nybbles
|
ocsenave@135
|
566 0x30
|
ocsenave@135
|
567 0x0C ;; increment C
|
ocsenave@137
|
568 0x3E ;; load 0x10 into A, to measure btns
|
ocsenave@135
|
569 0x10
|
ocsenave@135
|
570 0x18 ;; JUMP back to "load A into [FF00]" [20 steps?]
|
ocsenave@137
|
571 0xED
|
ocsenave@135
|
572
|
ocsenave@138
|
573
|
ocsenave@138
|
574 ;; ------ TAKE ACTION BASED ON USER INPUT
|
ocsenave@138
|
575
|
ocsenave@138
|
576 ;; mode 0x00 : select mode
|
ocsenave@138
|
577 ;; mode 0x08 : select bytes-to-write
|
ocsenave@138
|
578 ;; mode 0x10 : select hi-bit
|
ocsenave@138
|
579 ;; mode 0x18 : select lo-bit
|
ocsenave@138
|
580
|
ocsenave@138
|
581 ;; mode 0xF0 : write bytes
|
ocsenave@138
|
582 ;; mode 0xFF : jump PC
|
ocsenave@138
|
583
|
ocsenave@138
|
584
|
ocsenave@138
|
585 ;; registers
|
ocsenave@138
|
586 ;; D : mode select
|
ocsenave@138
|
587 ;; E : count of bytes to write
|
ocsenave@138
|
588 ;; H : address-high
|
ocsenave@138
|
589 ;; L : address-low
|
ocsenave@138
|
590
|
ocsenave@135
|
591 ;; now A contains the pressed keys
|
ocsenave@138
|
592 0x2F ; complement A, by request. [D34F]
|
ocsenave@137
|
593
|
ocsenave@138
|
594 0x47 ; A->B ;; now B contains the pressed keys
|
ocsenave@138
|
595 0x7B ; E->A ;; now A contains the count.
|
ocsenave@138
|
596
|
ocsenave@138
|
597 0xCB ; test bit 4 of D (are we in o/p mode?)
|
ocsenave@138
|
598 0x26
|
ocsenave@138
|
599 0x28 ; if test == 0, skip this o/p section
|
ocsenave@138
|
600 0x13 ; JUMP
|
ocsenave@137
|
601
|
ocsenave@138
|
602 0xCB ; else, test bit 0 of D (fragile; are we in pc mode?)
|
ocsenave@138
|
603 0x42
|
ocsenave@138
|
604 0x28 ; if test == 0, skip the following command
|
ocsenave@138
|
605 0x01
|
ocsenave@137
|
606
|
ocsenave@138
|
607 ;; output mode I: moving the program counter
|
ocsenave@138
|
608 0xE9 ; ** move PC to (HL)
|
ocsenave@137
|
609
|
ocsenave@138
|
610 ;; output mode II: writing bytes
|
ocsenave@138
|
611 0xFE ; A compare 0. finished writing?
|
ocsenave@138
|
612 0x00
|
ocsenave@138
|
613 0x28 ; if we are not finished, skip cleanup
|
ocsenave@138
|
614 0x04 ; JUMP
|
ocsenave@137
|
615
|
ocsenave@138
|
616 ;; CLEANUP
|
ocsenave@138
|
617 ;; btw, A is already zero.
|
ocsenave@138
|
618 0xAF ; zero A [D35F]
|
ocsenave@138
|
619 0x57 ; A->D; makes D=0.
|
ocsenave@138
|
620 0x18 ; end of frame
|
ocsenave@138
|
621 0xBC
|
ocsenave@138
|
622
|
ocsenave@138
|
623 ;; ---- end of cleanup
|
ocsenave@137
|
624
|
ocsenave@138
|
625
|
ocsenave@138
|
626 ;; continue writing bytes
|
ocsenave@138
|
627 0x1D ;; decrement E, the number of bytes to write
|
ocsenave@138
|
628 0x78 ;; B->A; now A contains the pressed keys
|
ocsenave@138
|
629 0x77 ;; copy A to (HL)
|
ocsenave@138
|
630 0x23 ;; increment HL
|
ocsenave@138
|
631 0x18 ;; end frame.
|
ocsenave@138
|
632 0xC2 ;; TODO: set skip length backwards
|
ocsenave@137
|
633
|
ocsenave@137
|
634
|
ocsenave@138
|
635 ;; ---- end of o/p section
|
ocsenave@138
|
636
|
ocsenave@138
|
637 ;; get data
|
ocsenave@138
|
638 0x3E ;; load the constant 57 into A. [D369]
|
ocsenave@138
|
639 0x57
|
ocsenave@138
|
640 0x82 ;; add the mode to A
|
ocsenave@138
|
641 0xEA ;; store A into "thing to execute"
|
ocsenave@138
|
642 0x74
|
ocsenave@135
|
643 0xD3
|
ocsenave@138
|
644
|
ocsenave@138
|
645 0x3E ;; load the constant 8 into A
|
ocsenave@138
|
646 0x08
|
ocsenave@138
|
647 0x82 ;; add the mode to A
|
ocsenave@138
|
648 0x57 ;; store the incremented mode into D
|
ocsenave@138
|
649 0x78 ;; B->A; now A contains the pressed keys
|
ocsenave@135
|
650
|
ocsenave@138
|
651 0x00 ;; var: thing to execute [D374]
|
ocsenave@138
|
652
|
ocsenave@138
|
653 0x18 ;; end frame
|
ocsenave@138
|
654 0xA8 ;; JUMP
|
rlm@128
|
655 ]
|
rlm@128
|
656 )
|
rlm@128
|
657
|
rlm@128
|
658 (defn write-mem-dyl []
|
rlm@128
|
659 (-> (tick (mid-game))
|
rlm@128
|
660 (IE! 0)
|
rlm@128
|
661 (inject-item-assembly (write-memory-assembly*))))
|
rlm@131
|
662
|
rlm@131
|
663
|
ocsenave@138
|
664 (defn dylan* []
|
ocsenave@138
|
665 (->
|
ocsenave@138
|
666 (write-mem-dyl)
|
ocsenave@138
|
667
|
ocsenave@138
|
668 (tick)
|
ocsenave@138
|
669 (tick)
|
ocsenave@138
|
670 (tick)
|
ocsenave@138
|
671 (tick)
|
ocsenave@138
|
672 (tick)
|
ocsenave@138
|
673 (tick)
|
ocsenave@138
|
674 (tick)
|
ocsenave@138
|
675 (tick)
|
ocsenave@138
|
676 (tick)
|
ocsenave@138
|
677 (tick)
|
ocsenave@138
|
678 (tick)
|
ocsenave@138
|
679 (tick)
|
ocsenave@138
|
680 (tick)
|
ocsenave@138
|
681 (tick)
|
ocsenave@138
|
682 (tick)
|
ocsenave@138
|
683 (tick)
|
ocsenave@138
|
684 (tick)
|
ocsenave@138
|
685 (tick)
|
ocsenave@138
|
686 (tick)
|
ocsenave@138
|
687 (tick)
|
ocsenave@138
|
688 (tick)
|
ocsenave@138
|
689 (tick)
|
ocsenave@138
|
690 (tick)
|
ocsenave@138
|
691 (tick)
|
ocsenave@138
|
692 (tick)
|
ocsenave@138
|
693 (tick)
|
ocsenave@138
|
694 (tick)
|
ocsenave@138
|
695 (tick)
|
ocsenave@138
|
696 (tick)
|
ocsenave@138
|
697 (tick)
|
ocsenave@138
|
698 (tick)
|
ocsenave@138
|
699 (tick)
|
ocsenave@138
|
700 (tick)
|
ocsenave@138
|
701 (tick)
|
ocsenave@138
|
702 (tick)
|
ocsenave@138
|
703 (tick)
|
ocsenave@138
|
704
|
ocsenave@138
|
705 ;;(view-memory 0xD374)
|
ocsenave@138
|
706 (tick)
|
ocsenave@138
|
707 (tick)
|
ocsenave@138
|
708 (tick)
|
ocsenave@138
|
709 (tick)
|
ocsenave@138
|
710 (tick)
|
ocsenave@138
|
711 (tick)
|
ocsenave@138
|
712 (tick)
|
ocsenave@138
|
713 (tick)
|
ocsenave@138
|
714 (tick)
|
ocsenave@138
|
715 (tick)
|
ocsenave@138
|
716 (tick)
|
ocsenave@138
|
717 (tick)
|
ocsenave@138
|
718 (tick)
|
ocsenave@138
|
719 (tick)
|
ocsenave@138
|
720 (tick)
|
ocsenave@138
|
721 ;;(view-memory 0xD374)
|
ocsenave@138
|
722 (d-tick)
|
ocsenave@138
|
723
|
ocsenave@138
|
724 (view-register "A" A)
|
ocsenave@138
|
725 (view-register "B" B)
|
ocsenave@138
|
726 (view-register "C" C))
|
ocsenave@138
|
727
|
ocsenave@138
|
728 )
|
ocsenave@138
|
729
|
ocsenave@138
|
730
|
ocsenave@135
|
731 (defn dylan []
|
ocsenave@135
|
732 (->
|
ocsenave@135
|
733 (write-mem-dyl)
|
ocsenave@135
|
734 (tick)
|
ocsenave@135
|
735 (tick)
|
ocsenave@135
|
736 (tick)
|
ocsenave@135
|
737 (tick)
|
ocsenave@135
|
738 (tick)
|
ocsenave@135
|
739 (tick)
|
ocsenave@135
|
740 (tick)
|
ocsenave@135
|
741 (tick)
|
ocsenave@135
|
742 (tick)
|
ocsenave@135
|
743 (tick)
|
ocsenave@135
|
744 (tick)
|
ocsenave@135
|
745 (tick)
|
ocsenave@135
|
746 (tick)
|
ocsenave@135
|
747 (tick)
|
ocsenave@136
|
748 (tick) ;; first loop
|
ocsenave@136
|
749
|
ocsenave@136
|
750
|
ocsenave@135
|
751 (tick)
|
ocsenave@135
|
752 (tick)
|
ocsenave@135
|
753 (tick)
|
ocsenave@135
|
754 (tick)
|
ocsenave@135
|
755 (tick)
|
ocsenave@135
|
756 (tick)
|
ocsenave@135
|
757 (tick)
|
ocsenave@135
|
758 (tick)
|
ocsenave@135
|
759 (tick)
|
ocsenave@135
|
760 (tick)
|
ocsenave@135
|
761 (tick)
|
ocsenave@135
|
762 (tick)
|
ocsenave@136
|
763 (tick) ;; dpad bits
|
ocsenave@136
|
764
|
ocsenave@135
|
765 (tick)
|
ocsenave@135
|
766 (tick)
|
ocsenave@136
|
767 (tick)
|
ocsenave@136
|
768 (tick)
|
ocsenave@136
|
769 (tick)
|
ocsenave@136
|
770 (tick)
|
ocsenave@136
|
771 (tick)
|
ocsenave@136
|
772 (tick)
|
ocsenave@136
|
773 (d-tick)
|
ocsenave@135
|
774
|
ocsenave@135
|
775
|
ocsenave@135
|
776
|
ocsenave@135
|
777 (view-register "A" A)
|
ocsenave@135
|
778 (view-register "B" B)
|
ocsenave@135
|
779 (view-register "C" C)
|
ocsenave@135
|
780
|
ocsenave@135
|
781 ))
|
ocsenave@135
|
782
|
ocsenave@135
|
783
|
ocsenave@135
|
784
|
ocsenave@135
|
785
|
rlm@131
|
786 (defn d2 []
|
rlm@131
|
787 (->
|
rlm@131
|
788 (write-mem-dyl)
|
rlm@131
|
789 (view-memory 0xD31F)
|
rlm@131
|
790 step step step step step
|
rlm@131
|
791 (view-memory 0xD31F)))
|
rlm@131
|
792
|
rlm@131
|
793
|
rlm@131
|
794
|
ocsenave@135
|
795
|
ocsenave@135
|
796
|
ocsenave@135
|
797
|
ocsenave@135
|
798
|
ocsenave@135
|
799
|
ocsenave@135
|
800
|
ocsenave@135
|
801
|
ocsenave@135
|
802
|
ocsenave@135
|
803
|
ocsenave@135
|
804
|
ocsenave@135
|
805
|
ocsenave@135
|
806
|
ocsenave@135
|
807
|
rlm@131
|
808
|
rlm@131
|
809
|
rlm@128
|
810
|
rlm@128
|
811
|
rlm@118
|
812 (defn write-memory-assembly []
|
rlm@129
|
813 [
|
rlm@123
|
814 ;; Main Timing Loop
|
rlm@123
|
815 ;; Constantly check for v-blank and Trigger main state machine on
|
rlm@123
|
816 ;; every transtion from v-blank to non-v-blank.
|
rlm@129
|
817
|
rlm@123
|
818 0x18 ; D31D ; Variable declaration
|
rlm@123
|
819 0x02 ; D31E
|
rlm@123
|
820 0x00 ; D31F ; frame-count
|
rlm@123
|
821 0x00 ; D320 ; v-blank-prev
|
rlm@129
|
822
|
rlm@129
|
823 0xF0 ; D321 ; load v-blank mode flags into A
|
rlm@129
|
824 0x41
|
rlm@129
|
825 0x00
|
rlm@123
|
826
|
rlm@123
|
827
|
rlm@123
|
828 ;; Branch dependent on v-blank. v-blank happens when the last two
|
rlm@123
|
829 ;; bits in A are "01"
|
rlm@123
|
830 0xCB ; D324
|
rlm@123
|
831 0x4F ; D325
|
rlm@123
|
832
|
rlm@123
|
833 0xC2 ; D326 ; if bit-1 is not 0, then
|
rlm@124
|
834 0x3E ; D327 ; GOTO non-v-blank.
|
rlm@123
|
835 0xD3 ; D328
|
rlm@123
|
836
|
rlm@123
|
837 0xCB ; D329
|
rlm@123
|
838 0x47 ; D32A
|
rlm@123
|
839
|
rlm@123
|
840 0xCA ; D32B ; if bit-0 is not 1, then
|
rlm@124
|
841 0x3E ; D32C ; GOTO non-v-blank.
|
rlm@123
|
842 0xD3 ; D32D
|
rlm@123
|
843
|
rlm@123
|
844 ;; V-Blank
|
rlm@123
|
845 ;; Activate state-machine if this is a transition event.
|
rlm@123
|
846
|
rlm@123
|
847 0xFA ; D32E ; load v-bank-prev into A
|
rlm@123
|
848 0x20 ; D32F
|
rlm@123
|
849 0xD3 ; D330
|
rlm@123
|
850
|
rlm@124
|
851 0xFE ; D331 ; compare A to 0. >--------\
|
rlm@124
|
852 0x00 ; D332 \
|
rlm@124
|
853 ; |
|
rlm@124
|
854 ;; set v-blank-prev to 1. |
|
rlm@124
|
855 0x3E ; D333 ; load 1 into A. |
|
rlm@124
|
856 0x01 ; D334 |
|
rlm@124
|
857 ; |
|
rlm@124
|
858 0xEA ; D335 ; load A into v-blank-prev |
|
rlm@124
|
859 0x20 ; D336 |
|
rlm@124
|
860 0xD3 ; D337 |
|
rlm@124
|
861 ; /
|
rlm@124
|
862 ;; if v-blank-prev was 0, activate state-machine <------/
|
rlm@124
|
863 0xCA ; D338 ; if v-blank-prev
|
rlm@123
|
864 0x46 ; D339 ; was 0,
|
rlm@123
|
865 0xD3 ; D33A ; GOTO state-machine
|
rlm@123
|
866
|
rlm@123
|
867 0xC3 ; D33B
|
rlm@123
|
868 0x1D ; D33C
|
rlm@123
|
869 0xD3 ; D33D ; GOTO beginning
|
rlm@123
|
870 ;; END V-blank
|
rlm@123
|
871
|
rlm@123
|
872 ;; Non-V-Blank
|
rlm@123
|
873 ;; Set v-blank-prev to 0
|
rlm@123
|
874 0x3E ; D33E ; load 0 into A
|
rlm@123
|
875 0x00 ; D33F
|
rlm@123
|
876
|
rlm@123
|
877 0xEA ; D340 ; load A into v-blank-prev
|
rlm@123
|
878 0x20 ; D341
|
rlm@123
|
879 0xD3 ; D342
|
rlm@118
|
880
|
rlm@123
|
881 0xC3 ; D343
|
rlm@123
|
882 0x1D ; D344
|
rlm@123
|
883 0xD3 ; D345 ; GOTO beginning
|
rlm@123
|
884 ;; END Not-V-Blank
|
rlm@115
|
885
|
rlm@124
|
886
|
rlm@123
|
887 ;; Main State Machine -- Input Section
|
rlm@123
|
888 ;; This is called once every frame.
|
rlm@123
|
889 ;; It collects input and uses it to drive the
|
rlm@123
|
890 ;; state transitions.
|
rlm@123
|
891
|
rlm@123
|
892 ;; Increment frame-count
|
rlm@123
|
893 0xFA ; D346 ; load frame-count into A
|
rlm@123
|
894 0x1F ; D347
|
rlm@123
|
895 0xD3 ; D348
|
rlm@118
|
896
|
rlm@123
|
897 0x3C ; D349 ; inc A
|
rlm@115
|
898
|
rlm@123
|
899 0xEA ; D34A
|
rlm@123
|
900 0x1F ; D34B ; load A into frame-count
|
rlm@123
|
901 0xD3 ; D34C
|
rlm@118
|
902
|
rlm@123
|
903 0x00 ; D34D ; glue :)
|
rlm@118
|
904
|
rlm@118
|
905 0x18 ;D34E ; skip next 3 bytes
|
rlm@118
|
906 0x03 ;D34F
|
rlm@123
|
907 ;D350
|
rlm@118
|
908 (Integer/parseInt "00100000" 2) ; select directional pad
|
rlm@123
|
909 ;D351
|
rlm@118
|
910 (Integer/parseInt "00010000" 2) ; select buttons
|
rlm@118
|
911 0x00 ;D352 ; input-number
|
rlm@118
|
912
|
rlm@123
|
913 ;; select directional pad; store low bits in B
|
rlm@118
|
914
|
rlm@118
|
915 0xFA ;D353 ; load (D350) into A
|
rlm@118
|
916 0x50 ;D354 -->
|
rlm@123
|
917 0xD3 ;D355 --> D350
|
rlm@118
|
918
|
rlm@129
|
919 0xE0 ;D356 ; load (A), which is
|
rlm@118
|
920 0x00 ;D357 --> ; 00010000, into FF00
|
rlm@129
|
921 0x00 ;D358 --> FF00 ;; NO-OP
|
rlm@118
|
922
|
rlm@118
|
923 0x06 ;D359
|
rlm@123
|
924 ;D35A
|
rlm@118
|
925 (Integer/parseInt "11110000" 2) ; "11110000" -> B
|
rlm@129
|
926 0xF0 ;D35B ; (FF00) -> A
|
rlm@118
|
927 0x00 ;D35C
|
rlm@129
|
928 0x00 ;D35D ;; NO-OP
|
rlm@118
|
929
|
rlm@118
|
930 0xCB ;D35E ; swap nybbles on A
|
rlm@118
|
931 0x37 ;D35F
|
rlm@118
|
932 0xA0 ;D360 ; (AND A B) -> A
|
rlm@118
|
933 0x47 ;D361 ; A -> B
|
rlm@118
|
934
|
rlm@123
|
935 ;; select buttons; store bottom bits in C
|
rlm@118
|
936
|
rlm@118
|
937 0xFA ;D362 ; load (D351) into A
|
rlm@118
|
938 0x51 ;D363 -->
|
rlm@123
|
939 0xD3 ;D364 --> D351
|
rlm@118
|
940
|
rlm@129
|
941 0xE0 ;D365 ; load (A), which is
|
rlm@118
|
942 0x00 ;D366 --> ; 00001000, into FF00
|
rlm@129
|
943 0x00 ;D367 --> FF00 ;; NO-OP
|
rlm@118
|
944
|
rlm@118
|
945 0x0E ;D368
|
rlm@118
|
946 ;D369
|
rlm@118
|
947 (Integer/parseInt "00001111" 2) ; "00001111" -> C
|
rlm@118
|
948
|
rlm@129
|
949 0xF0 ;D36A ; (FF00) -> A
|
rlm@118
|
950 0x00 ;D36B
|
rlm@129
|
951 0x00 ;D36C
|
rlm@118
|
952
|
rlm@118
|
953 0xA1 ;D36D ; (AND A C) -> A
|
rlm@118
|
954 0x4F ;D36E ; A -> C
|
rlm@118
|
955
|
rlm@118
|
956 ;; combine the B and C registers into the input number
|
rlm@118
|
957 0x79 ;D36F ; C -> A
|
rlm@118
|
958 0xB0 ;D370 ; (OR A B) -> A
|
rlm@118
|
959 0x2F ;D371 ; negate A
|
rlm@118
|
960
|
rlm@118
|
961 0xEA ;D372 ; store A into input-number
|
rlm@118
|
962 0x52 ;D373
|
rlm@118
|
963 0xD3 ;D374
|
rlm@118
|
964
|
rlm@124
|
965 0x00 ;D375
|
rlm@124
|
966 0x00 ;D376
|
rlm@124
|
967 0x00 ;D377
|
rlm@118
|
968 0x00 ;D378
|
rlm@118
|
969 0x00 ;D379
|
rlm@118
|
970 0x00 ;D37A
|
rlm@118
|
971 0x00 ;D37B ; these are here because
|
rlm@118
|
972 0x00 ;D37C ; I messed up :(
|
rlm@118
|
973 0x00 ;D37D
|
rlm@118
|
974 0x00 ;D37E
|
rlm@118
|
975 0x00 ;D37F
|
rlm@118
|
976
|
rlm@118
|
977 ;; beginning of main state machine
|
rlm@118
|
978 0x18 ;D380 ; Declaration of variables
|
rlm@118
|
979 0x05 ;D381 ; 5 variables:
|
rlm@118
|
980 0x00 ;D382 ; current-mode
|
rlm@122
|
981 0x00 ;D383 ; bytes-to-write
|
rlm@126
|
982 0x00 ;D384 ; bytes-written
|
rlm@126
|
983 0x00 ;D385 ; start-point-high
|
rlm@126
|
984 0x00 ;D386 ; start-point-low
|
rlm@118
|
985
|
rlm@118
|
986
|
rlm@118
|
987 ;; banch on current mode
|
rlm@118
|
988 0xFA ;D387 ; load current-mode (0xD382)
|
rlm@118
|
989 0x82 ;D388 ; into A
|
rlm@118
|
990 0xD3 ;D389
|
rlm@118
|
991 0x00 ;D38A
|
rlm@118
|
992
|
rlm@120
|
993
|
rlm@120
|
994 ;; GOTO Mode 0 (input-mode) if current-mode is 0
|
rlm@118
|
995 0xFE ;D38B
|
rlm@118
|
996 0x00 ;D38C ; compare A with 0x00
|
rlm@118
|
997
|
rlm@120
|
998 0xCA ;D38D ; goto Mode 0 if A == 0
|
rlm@118
|
999 0xA8 ;D38E
|
rlm@118
|
1000 0xD3 ;D38F
|
rlm@118
|
1001
|
rlm@121
|
1002 ;; GOTO Mode 1 (set-length) if current-mode is 1
|
rlm@120
|
1003 0xFE ;D390
|
rlm@120
|
1004 0x01 ;D391 ; compare A with 0x01
|
rlm@120
|
1005
|
rlm@120
|
1006 0xCA ;D392
|
rlm@120
|
1007 0xB1 ;D393
|
rlm@120
|
1008 0xD3 ;D394 ; goto Mode 1 if A == 1
|
rlm@120
|
1009
|
rlm@126
|
1010 ;; GOTO Mode 2 (set-start-point-high) if current mode is 2
|
rlm@121
|
1011 0xFE ;D395
|
rlm@121
|
1012 0x02 ;D396 ; compare A with 0x02
|
rlm@121
|
1013
|
rlm@121
|
1014 0xCA ;D397
|
rlm@121
|
1015 0xBF ;D398
|
rlm@121
|
1016 0xD3 ;D399 ; goto Mode 2 if A == 2
|
rlm@121
|
1017
|
rlm@126
|
1018 ;; GOTO Mode 3 (set-start-point-low) if current mode is 3
|
rlm@125
|
1019 0xFE ;D39A
|
rlm@125
|
1020 0x03 ;D39B
|
rlm@125
|
1021
|
rlm@126
|
1022 0xCA ;D39C
|
rlm@126
|
1023 0xCD ;D39D
|
rlm@126
|
1024 0xD3 ;D39E ; goto Mode 3 if A == 3
|
rlm@126
|
1025
|
rlm@127
|
1026 ;; GOTO Mode 4 (write-memory) if current mode is 4
|
rlm@127
|
1027 0xFE ;D39F
|
rlm@127
|
1028 0x04 ;D3A0
|
rlm@127
|
1029
|
rlm@127
|
1030 0xCA ;D3A1
|
rlm@127
|
1031 0xDB ;D3A2
|
rlm@127
|
1032 0xD3 ;D3A3
|
rlm@127
|
1033
|
rlm@118
|
1034 0x00 ;D3A4
|
rlm@118
|
1035 ;; End of Mode checking, goto beginning
|
rlm@118
|
1036 0xC3 ;D3A5
|
rlm@118
|
1037 0x1D ;D3A6
|
rlm@118
|
1038 0xD3 ;D3A7
|
rlm@120
|
1039
|
rlm@120
|
1040
|
rlm@120
|
1041 ;; Mode 0 -- input-mode mode
|
rlm@120
|
1042 ;; means that we are waiting for a mode, so set the mode to
|
rlm@120
|
1043 ;; whatever is currently in input-number. If nothing is
|
rlm@120
|
1044 ;; entered, then the program stays in input-mode mode
|
rlm@120
|
1045
|
rlm@118
|
1046 ;; set current-mode to input-number
|
rlm@118
|
1047 0xFA ;D3A8 ; load input-number (0xD352)
|
rlm@118
|
1048 0x52 ;D3A9 ; into A
|
rlm@118
|
1049 0xD3 ;D3AA
|
rlm@118
|
1050
|
rlm@118
|
1051 0xEA ;D3AB ; load A into current-mode
|
rlm@118
|
1052 0x82 ;D3AC ; (0xD382)
|
rlm@118
|
1053 0xD3 ;D3AD
|
rlm@118
|
1054
|
rlm@118
|
1055 0xC3 ;D3AE ; go back to beginning
|
rlm@118
|
1056 0x1D ;D3AF
|
rlm@118
|
1057 0xD3 ;D3B0
|
rlm@120
|
1058 ;; End Mode 0
|
rlm@118
|
1059
|
rlm@120
|
1060
|
rlm@121
|
1061 ;; Mode 1 -- set-length mode
|
rlm@121
|
1062 ;; This is the header for writing things to memory.
|
rlm@121
|
1063 ;; User specifies the number of bytes to write.
|
rlm@120
|
1064 ;; Mode is auto advanced to Mode 2 after this mode
|
rlm@120
|
1065 ;; completes.
|
rlm@120
|
1066
|
rlm@121
|
1067 ;; Set bytes left to write to input-number;
|
rlm@120
|
1068 ;; set current-mode to 0x02.
|
rlm@120
|
1069 0xFA ;D3B1 ; load input-number (0xD352)
|
rlm@120
|
1070 0x52 ;D3B2 ; into A
|
rlm@120
|
1071 0xD3 ;D3B3
|
rlm@120
|
1072
|
rlm@120
|
1073 0xEA ;D3B4 ; load A into bytes-left-to-write
|
rlm@120
|
1074 0x83 ;D3B5 ; (0xD383)
|
rlm@120
|
1075 0xD3 ;D3B6
|
rlm@120
|
1076
|
rlm@121
|
1077 0x3E ;D3B7 ; load 0x02 into A.
|
rlm@120
|
1078 0x02 ;D3B8
|
rlm@120
|
1079
|
rlm@120
|
1080 0xEA ;D3B9 ; load A to current-mode
|
rlm@120
|
1081 0x82 ;D3BA ; advancing from Mode 1 to
|
rlm@120
|
1082 0xD3 ;D3BB ; Mode 2
|
rlm@120
|
1083
|
rlm@120
|
1084 0xC3 ;D3BC ; go back to beginning
|
rlm@120
|
1085 0x1D ;D3BD
|
rlm@120
|
1086 0xD3 ;D3BE
|
rlm@120
|
1087 ;; End Mode 1
|
rlm@121
|
1088
|
rlm@121
|
1089
|
rlm@126
|
1090 ;; Mode 2 -- set start-point-high mode
|
rlm@126
|
1091 ;; Middle part of the header for writing things to memory.
|
rlm@121
|
1092 ;; User specifies the start location in RAM to which
|
rlm@121
|
1093 ;; data will be written.
|
rlm@121
|
1094 ;; Mode is auto advanced to Mode 3 after this mode completes.
|
rlm@121
|
1095
|
rlm@126
|
1096 ;; Set start-point-high to input-number;
|
rlm@121
|
1097 ;; set current mode to 0x03.
|
rlm@121
|
1098 0xFA ;D3BF ; load input-number (0xD352)
|
rlm@121
|
1099 0x52 ;D3C0 ; into A
|
rlm@121
|
1100 0xD3 ;D3C1
|
rlm@121
|
1101
|
rlm@126
|
1102 0xEA ;D3C2 ; load A into start-point-high
|
rlm@126
|
1103 0x85 ;D3C3 ; (0xD385)
|
rlm@121
|
1104 0xD3 ;D3C4
|
rlm@121
|
1105
|
rlm@121
|
1106 0x3E ;D3C5 ; load 0x03 into A.
|
rlm@121
|
1107 0x03 ;D3C6
|
rlm@121
|
1108
|
rlm@121
|
1109 0xEA ;D3C7 ; load A to current-mode,
|
rlm@121
|
1110 0x82 ;D3C8 ; advancing from Mode 2 to
|
rlm@121
|
1111 0xD3 ;D3C9 ; Mode 3.
|
rlm@120
|
1112
|
rlm@121
|
1113 0xC3 ;D3CA ; go back to beginning
|
rlm@121
|
1114 0x1D ;D3CB
|
rlm@121
|
1115 0xD3 ;D3CC
|
rlm@121
|
1116 ;;End Mode 2
|
rlm@125
|
1117
|
rlm@118
|
1118
|
rlm@126
|
1119 ;; Mode 3 -- set-start-point-low mode
|
rlm@126
|
1120 ;; Final part of header for writing things to memory.
|
rlm@126
|
1121 ;; User specifies the low bytes of 16 bit start-point.
|
rlm@126
|
1122
|
rlm@126
|
1123 ;; Set start-point-low to input-number;
|
rlm@126
|
1124 ;; set current mode to 0x04
|
rlm@126
|
1125 0xFA ;D3CD ; load input-number into A
|
rlm@126
|
1126 0x52 ;D3CE
|
rlm@126
|
1127 0xD3 ;D3CF
|
rlm@126
|
1128
|
rlm@126
|
1129 0xEA ;D3D0 ; load A into start-point-low
|
rlm@126
|
1130 0x86 ;D3D1
|
rlm@126
|
1131 0xD3 ;D3D2
|
rlm@126
|
1132
|
rlm@126
|
1133 0x3E ;D3D3 ; load 0x04 into A.
|
rlm@126
|
1134 0x04 ;D3D4
|
rlm@126
|
1135
|
rlm@126
|
1136 0xEA ;D3D5 ; load A to current-mode,
|
rlm@126
|
1137 0x82 ;D3D6 ; advancing from Mode 3 to
|
rlm@126
|
1138 0xD3 ;D3D7 ; Mode 4.
|
rlm@126
|
1139
|
rlm@126
|
1140 0xC3 ;D3D8 ; go back to beginning
|
rlm@126
|
1141 0x1D ;D3D9
|
rlm@126
|
1142 0xD3 ;D3DA
|
rlm@126
|
1143
|
rlm@126
|
1144 ;; Mode 4 -- write bytes mode
|
rlm@125
|
1145
|
rlm@125
|
1146 ;; This is where RAM manipulation happens. User supplies
|
rlm@125
|
1147 ;; bytes every frame, which are written sequentially to
|
rlm@125
|
1148 ;; start-point until bytes-to-write have been written. Once
|
rlm@125
|
1149 ;; bytes-to-write have been written, the mode is reset to 0.
|
rlm@125
|
1150
|
rlm@125
|
1151 ;; compare bytes-written with bytes-to-write.
|
rlm@125
|
1152 ;; if they are the same, then reset mode to 0
|
rlm@125
|
1153
|
rlm@126
|
1154 0xFA ;D3DB ; load bytes-to-write into A
|
rlm@126
|
1155 0x83 ;D3DC
|
rlm@126
|
1156 0xD3 ;D3DD
|
rlm@127
|
1157
|
rlm@126
|
1158 0x47 ;D3DE ; load A into B
|
rlm@127
|
1159
|
rlm@126
|
1160 0xFA ;D3DF ; load bytes-written into A
|
rlm@126
|
1161 0x84 ;D3E0
|
rlm@126
|
1162 0xD3 ;D3E1
|
rlm@127
|
1163
|
rlm@126
|
1164 0xB8 ;D3E2 ; compare A with B
|
rlm@127
|
1165
|
rlm@126
|
1166 0xCA ;D3E3 ; if they are equal, go to cleanup
|
rlm@127
|
1167 0x07 ;D3E4
|
rlm@127
|
1168 0xD4 ;D3E5
|
rlm@125
|
1169
|
rlm@125
|
1170 ;; Write Memory Section
|
rlm@125
|
1171 ;; Write the input-number, interpreted as an 8-bit number,
|
rlm@125
|
1172 ;; into the current target register, determined by
|
rlm@125
|
1173 ;; (+ start-point bytes-written).
|
rlm@125
|
1174 ;; Then, increment bytes-written by 1.
|
rlm@125
|
1175
|
rlm@127
|
1176 0xFA ;D3E6 ; load start-point-high into A
|
rlm@127
|
1177 0x85 ;D3E7
|
rlm@127
|
1178 0xD3 ;D3E8
|
rlm@127
|
1179
|
rlm@127
|
1180 0x67 ;D3E9 ; load A into H
|
rlm@127
|
1181
|
rlm@127
|
1182 0xFA ;D3EA ; load start-point-low into A
|
rlm@127
|
1183 0x86 ;D3EB
|
rlm@127
|
1184 0xD3 ;D3EC
|
rlm@127
|
1185
|
rlm@127
|
1186 0x6F ;D3ED ; load A into L
|
rlm@127
|
1187
|
rlm@127
|
1188 0xFA ;D3EE ; load bytes-written into A
|
rlm@127
|
1189 0x84 ;D3EF
|
rlm@127
|
1190 0xD3 ;D3F0
|
rlm@127
|
1191
|
rlm@127
|
1192 0x00 ;D3F1 ; These are here because
|
rlm@127
|
1193 0x00 ;D3F2 ; I screwed up again.
|
rlm@125
|
1194 0x00 ;D3F3
|
rlm@125
|
1195
|
rlm@127
|
1196 0x85 ;D3F4 ; add L to A; store A in L.
|
rlm@127
|
1197 0x6F ;D3F5
|
rlm@121
|
1198
|
rlm@127
|
1199 0x30 ;D3F6 ; If the addition overflowed,
|
rlm@127
|
1200 0x01 ;D3F7
|
rlm@127
|
1201 0x24 ;D3F8 ; increment H.
|
rlm@118
|
1202
|
rlm@127
|
1203 ;; Now, HL points to the correct place in memory
|
rlm@127
|
1204
|
rlm@127
|
1205 0xFA ;D3F9 ; load input-number into A
|
rlm@127
|
1206 0x52 ;D3FA
|
rlm@127
|
1207 0xD3 ;D3FB
|
rlm@118
|
1208
|
rlm@127
|
1209 0x77 ;D3FC ; load A into (HL)
|
rlm@118
|
1210
|
rlm@127
|
1211 0xFA ;D3FD ; load bytes-written into A
|
rlm@127
|
1212 0x84 ;D3FE
|
rlm@127
|
1213 0xD3 ;D3FF
|
rlm@118
|
1214
|
rlm@127
|
1215 0x3C ;D400 ; increment A
|
rlm@127
|
1216
|
rlm@127
|
1217 0xEA ;D401 ; load A into bytes-written
|
rlm@127
|
1218 0x84 ;D402
|
rlm@127
|
1219 0xD3 ;D403
|
rlm@127
|
1220
|
rlm@127
|
1221 0xC3 ;D404 ; go back to beginning.
|
rlm@127
|
1222 0x1D ;D405
|
rlm@127
|
1223 0xD3 ;D406
|
rlm@127
|
1224 ;; End Write Memory Section
|
rlm@127
|
1225
|
rlm@127
|
1226 ;; Mode 4 Cleanup Section
|
rlm@127
|
1227 ;; reset bytes-written to 0
|
rlm@127
|
1228 ;; set mode to 0
|
rlm@127
|
1229 0x3E ;D407 ; load 0 into A
|
rlm@127
|
1230 0x00 ;D408
|
rlm@127
|
1231
|
rlm@127
|
1232 0xEA ;D409 ; load A into bytes-written
|
rlm@127
|
1233 0x84 ;D40A
|
rlm@127
|
1234 0xD3 ;D40B
|
rlm@127
|
1235
|
rlm@127
|
1236 0xEA ;D40C ; load A into current-mode
|
rlm@127
|
1237 0x82 ;D40D
|
rlm@127
|
1238 0xD3 ;D40E
|
rlm@127
|
1239
|
rlm@127
|
1240 0xC3 ;D40F ; go back to beginning
|
rlm@127
|
1241 0x1D ;D410
|
rlm@127
|
1242 0xD3 ;D411
|
rlm@127
|
1243
|
rlm@127
|
1244 ;; End Mode 4
|
rlm@118
|
1245
|
rlm@118
|
1246 ])
|
rlm@118
|
1247
|
rlm@118
|
1248
|
rlm@123
|
1249
|
rlm@118
|
1250 (def frame-count 0xD31F)
|
rlm@118
|
1251 (def input 0xD352)
|
rlm@127
|
1252 (def current-mode 0xD382)
|
rlm@127
|
1253 (def bytes-to-write 0xD383)
|
rlm@127
|
1254 (def bytes-written 0xD384)
|
rlm@127
|
1255 (def start-point-high 0xD385)
|
rlm@127
|
1256 (def start-point-low 0xD386)
|
rlm@126
|
1257
|
rlm@127
|
1258
|
rlm@118
|
1259
|
rlm@118
|
1260 (defn write-memory []
|
rlm@118
|
1261 (-> (tick (mid-game))
|
rlm@118
|
1262 (IE! 0) ; disable interrupts
|
rlm@118
|
1263 (inject-item-assembly (write-memory-assembly))))
|
rlm@119
|
1264
|
rlm@119
|
1265 (defn test-write-memory []
|
rlm@119
|
1266 (set-state! (write-memory))
|
rlm@119
|
1267 (dorun
|
rlm@119
|
1268 (dotimes [_ 5000]
|
rlm@119
|
1269 (view-memory (step @current-state) current-mode))))
|
rlm@122
|
1270
|
rlm@122
|
1271 (def bytes-to-write 0xD383)
|
rlm@122
|
1272 (def start-point 0xD384)
|
rlm@122
|
1273
|
rlm@125
|
1274 (defn print-blank-assembly
|
rlm@125
|
1275 [start end]
|
rlm@125
|
1276 (dorun
|
rlm@125
|
1277 (map
|
rlm@125
|
1278 #(println (format "0x00 ;%04X " %))
|
rlm@125
|
1279 (range start end))))
|
rlm@125
|
1280
|
rlm@122
|
1281 (defn test-mode-2 []
|
rlm@122
|
1282 (->
|
rlm@122
|
1283 (write-memory)
|
rlm@123
|
1284 (view-memory frame-count)
|
rlm@122
|
1285 (step)
|
rlm@122
|
1286 (step [:a])
|
rlm@122
|
1287 (step [:b])
|
rlm@122
|
1288 (step [:start])
|
rlm@122
|
1289 (step [])
|
rlm@123
|
1290 (view-memory frame-count)))
|
rlm@123
|
1291
|
rlm@128
|
1292 (defn test-mode-4
|
rlm@128
|
1293 ([] (test-mode-4 (write-memory)))
|
rlm@128
|
1294 ([target-state]
|
rlm@128
|
1295 (->
|
rlm@128
|
1296 target-state
|
rlm@128
|
1297 (#(do (println "memory from 0xC00F to 0xC01F:"
|
rlm@128
|
1298 (subvec (vec (memory %)) 0xC00F 0xC01F)) %))
|
rlm@128
|
1299 (view-memory current-mode)
|
rlm@128
|
1300 (step [])
|
rlm@128
|
1301 (step [])
|
rlm@128
|
1302 (step [])
|
rlm@128
|
1303 (#(do (println "after three steps") %))
|
rlm@128
|
1304 (view-memory current-mode)
|
rlm@127
|
1305
|
rlm@128
|
1306 ;; Activate memory writing mode
|
rlm@128
|
1307
|
rlm@128
|
1308 (#(do (println "step with [:a]") %))
|
rlm@128
|
1309 (step [:a])
|
rlm@128
|
1310 (view-memory current-mode)
|
rlm@128
|
1311 (view-memory bytes-to-write)
|
rlm@128
|
1312 (view-memory start-point-high)
|
rlm@128
|
1313 (view-memory start-point-low)
|
rlm@127
|
1314
|
rlm@128
|
1315 ;; Specify four bytes to be written
|
rlm@128
|
1316
|
rlm@128
|
1317 (#(do (println "step with [:select]")%))
|
rlm@128
|
1318 (step [:select])
|
rlm@128
|
1319 (view-memory current-mode)
|
rlm@128
|
1320 (view-memory bytes-to-write)
|
rlm@128
|
1321 (view-memory start-point-high)
|
rlm@128
|
1322 (view-memory start-point-low)
|
rlm@127
|
1323
|
rlm@128
|
1324 ;; Specify target memory address as 0xC00F
|
rlm@128
|
1325
|
rlm@128
|
1326 (#(do (println "step with [:u :d]")%))
|
rlm@128
|
1327 (step [:u :d])
|
rlm@128
|
1328 (view-memory current-mode)
|
rlm@128
|
1329 (view-memory bytes-to-write)
|
rlm@128
|
1330 (view-memory start-point-high)
|
rlm@128
|
1331 (view-memory start-point-low)
|
rlm@127
|
1332
|
rlm@128
|
1333 (#(do (println "step with [:a :b :start :select]")%))
|
rlm@128
|
1334 (step [:a :b :start :select])
|
rlm@128
|
1335 (view-memory current-mode)
|
rlm@128
|
1336 (view-memory bytes-to-write)
|
rlm@128
|
1337 (view-memory start-point-high)
|
rlm@128
|
1338 (view-memory start-point-low)
|
rlm@127
|
1339
|
rlm@128
|
1340 ;; Start reprogramming memory
|
rlm@127
|
1341
|
rlm@128
|
1342 (#(do (println "step with [:a]")%))
|
rlm@128
|
1343 (step [:a])
|
rlm@128
|
1344 (view-memory current-mode)
|
rlm@128
|
1345 (view-memory bytes-written)
|
rlm@127
|
1346
|
rlm@128
|
1347 (#(do (println "step with [:b]")%))
|
rlm@128
|
1348 (step [:b])
|
rlm@128
|
1349 (view-memory current-mode)
|
rlm@128
|
1350 (view-memory bytes-written)
|
rlm@127
|
1351
|
rlm@128
|
1352 (#(do (println "step with [:a :b]")%))
|
rlm@128
|
1353 (step [:a :b])
|
rlm@128
|
1354 (view-memory current-mode)
|
rlm@128
|
1355 (view-memory bytes-written)
|
rlm@127
|
1356
|
rlm@128
|
1357 (#(do (println "step with [:select]")%))
|
rlm@128
|
1358 (step [:select])
|
rlm@128
|
1359 (view-memory current-mode)
|
rlm@128
|
1360 (view-memory bytes-written)
|
rlm@127
|
1361
|
rlm@128
|
1362 ;; Reprogramming done, program ready for more commands.
|
rlm@127
|
1363
|
rlm@128
|
1364 (#(do (println "step with []")%))
|
rlm@128
|
1365 (step [])
|
rlm@128
|
1366 (view-memory current-mode)
|
rlm@128
|
1367 (view-memory bytes-written)
|
rlm@128
|
1368
|
rlm@128
|
1369 (#(do (println "memory from 0xC00F to 0xC01F:"
|
rlm@128
|
1370 (subvec (vec (memory %)) 0xC00F 0xC01F)) %)))))
|
rlm@123
|
1371
|