Mercurial > hg > Members > kono > nitros9-code
view 3rdparty/packages/sierra/objs/shdw.asm @ 1057:33f92984ce41
Minor comment additions
| author | pwz |
|---|---|
| date | Wed, 26 Mar 2003 09:23:12 +0000 |
| parents | a3faad87fa9f |
| children | 4c5e21e215f6 |
line wrap: on
line source
******************************************************************** * SHDW - Kings Quest III screen rendering module?? * $Id$ * * Ed. Comments Who YY/MM/DD * ------------------------------------------------------------------ * 0 Disassembly of original distribution PWZ 03/03/14 * using a combination of disasm v1.6 and * the os9tools disassembler Os9disasm * * Note the header shows a data size of 0 * called from the sierra module and accesses * data set up in that module * * Much credit and thanks is give to Nick Sonneveld and * the other NAGI folks. Following his sources made it * so much easier to document what was happening in here. * This source will assemble byte for byte * to the original kq3 shdw module. * * Header for : shdw * Module size: $A56 #2646 * Module CRC : $E9E019 (Good) * Hdr parity : $74 * Exec. off : $0012 #18 * Data size : $0000 #0 * Edition : $00 #0 * Ty/La At/Rv: $11 $81 * Prog mod, 6809 Obj, re-ent, R/O * Disassembly by Os9disasm of shdw nam shdw ttl program module ifp1 use defsfile endc tylg set Prgrm+Objct atrv set ReEnt+rev rev set $01 mod eom,name,tylg,atrv,start,size size equ . Xffa9 equ $FFA9 task 1 block 2 X01af equ $01AF a state.flag byte X0551 equ $0551 given_pic_data * OS9 data area definitions u001a equ $001A shdw MMU block data u002e equ $002E Load offset u0042 equ $0042 Sierra process descriptor block u0043 equ $0043 Sierra 2nd 8K data block u005a equ $005A color u005b equ $005B sbuff_drawmask u005c equ $005C flag_control u006b equ $006B pen_status * these look like gen purpose scratch vars u009e equ $009E u009f equ $009F u00a0 equ $00A0 u00a1 equ $00A1 u00a2 equ $00A2 u00a3 equ $00A3 u00a4 equ $00A4 u00a5 equ $00A5 u00a6 equ $00A6 u00a7 equ $00A7 u00a8 equ $00A8 u00a9 equ $00A9 u00aa equ $00AA u00ab equ $00AB u00ac equ $00AC u00ad equ $00AD u00ae equ $00AE u00af equ $00AF u00b0 equ $00B0 u00b2 equ $00B2 u00b3 equ $00B3 * VIEW OBJECTS FLAGS O_DRAWN equ $01 * 0 - object has been drawn O_BLKIGNORE equ $02 * 1 - ignore blocks and condition lines O_PRIFIXED equ $04 * 2 - fixes priority agi cannot change it based on position O_HRZNIGNORE equ $08 * 3 - ignore horizon O_UPDATE equ $10 * 4 - update every cycle O_CYCLE equ $20 * 5 - the object cycles O_ANIMATE equ $40 * 6 - animated O_BLOCK equ $80 * 7 - resting on a block O_WATER equ $100 * 8 - only allowed on water O_OBJIGNORE equ $200 * 9 - ignore other objects when determining contacts O_REPOS equ $400 * 10 - set whenever a obj is repositioned * that way the interpeter doesn't check it's next movement for one cycle O_LAND equ $800 * 11 - only allowed on land O_SKIPUPDATE equ $1000 * 12 - does not update obj for one cycle O_LOOPFIXED equ $2000 * 13 - agi cannot set the loop depending on direction O_MOTIONLESS equ $4000 * 14 - no movement. * if position is same as position in last cycle then this flag is set. * follow/wander code can then create a new direction * (ie, if it hits a wall or something) O_UNUSED equ $8000 * Local Program Defines PICBUFF_WIDTH equ 160 ($A0) PICBUFF_HEIGHT equ 168 ($A8) picb_size equ PICBUFF_WIDTH*PICBUFF_HEIGHT $6900 x_max equ PICBUFF_WIDTH-1 159 ($9F) y_max equ PICBUFF_HEIGHT-1 167 ($A7) gfx_picbuff equ $6040 screen buff low address gbuffend equ gfx_picbuff+picb_size screen buff high address $C940 blit_end equ gfx_picbuff+$6860 cmd_start equ $F0 first command value name equ * L000d fcs 'shdw' fcb $00 * This module is linked to in sierra start equ * L0012 lbra L05fb gfx_picbuff_update_remap lbra L0713 obj_chk_control lbra L0175 render_pic (which calls pic_cmd_loop) lbra L0189 pic_cmd_loop lbra L07be obj_blit lbra L0927 obj_add_pic_pri lbra L0a0f blit_restore lbra L09d8 blit_save lbra L040e sbuff_fill lbra L063a blitlist_draw lbra L0615 blitlist_erase fcc 'AGI (c) copyright 1988 SIERRA On-Line' fcc 'CoCo3 version by Chris Iden' fcb C$NULL * Twiddles with MMU * accd is loaded by calling program * * u001a = shdw mem block data * u0042 = sierra process descriptor block * u0043 = Sierra 2nd 8K data block L0074 cmpa u001a compare to shdw mem block beq L008e equal ?? no work to be done move on orcc #IntMasks turn off interupts sta u001a store the value passed in by a lda u0042 get sierra process descriptor map block sta Xffa9 map it in to $2000-$3FFF ldu u0043 2nd 8K data block in Sierra lda u001a load my mem block value sta ,u save my values at address held in u0043 stb $02,u std Xffa9 map it to task 1 block 2 andcc #^IntMasks restore the interupts L008e rts we done L008f fcb $00 load offsets updated flag * binary_list[] (pic_render.c) L0090 fdb $8000 fdb $4000 fdb $2000 fdb $1000 fdb $0800 fdb $0400 fdb $0200 fdb $0100 fdb $0080 fdb $0040 fdb $0020 fdb $0010 fdb $0008 fdb $0004 fdb $0002 fdb $0001 * circle_data[] (pic_render.c) L00b0 fdb $8000 fdb $e000 fdb $e000 fdb $e000 fdb $7000 fdb $f800 fdb $f800 fdb $f800 fdb $7000 fdb $3800 fdb $7c00 fdb $fe00 fdb $fe00 fdb $fe00 fdb $7c00 fdb $3800 fdb $1c00 fdb $7f00 fdb $ff80 fdb $ff80 fdb $ff80 fdb $ff80 fdb $ff80 fdb $7f00 fdb $1c00 fdb $0e00 fdb $3f80 fdb $7fc0 fdb $7fc0 fdb $ffe0 fdb $ffe0 fdb $ffe0 fdb $7fc0 fdb $7fc0 fdb $3f80 fdb $1f00 fdb $0e00 fdb $0f80 fdb $3fe0 fdb $7ff0 fdb $7ff0 fdb $fff8 fdb $fff8 fdb $fff8 fdb $fff8 fdb $fff8 fdb $7ff0 fdb $7ff0 fdb $3fe0 fdb $0f80 fdb $07c0 fdb $1ff0 fdb $3ff8 fdb $7ffc fdb $7ffc fdb $fffe fdb $fffe fdb $fffe fdb $fffe fdb $fffe fdb $7ffc fdb $7ffc fdb $3ff8 fdb $1ff0 fdb $07c0 * circle_list[] (pic_render.c) * this data is different in the file * { 0, 1, 4, 9, 16, 25, 37, 50 } * These run like a set of numbers**2 {0,1,2,3,4,5,~6,~7} * ah ha these are multiples 2*(0,1,2,3,4,5,~6,~7)**2) L0132 fcb $00,$00 0 fcb $00,$02 2 fcb $00,$08 8 fcb $00,$12 18 fcb $00,$20 32 fcb $00,$32 50 fcb $00,$4a 74 fcb $00,$64 100 * select case dispatch table for pic_cmd_loop() L0142 fdb $01bc enable_pic_draw() fdb $01c9 disable_pic_draw() fdb $01d4 enable_pri_draw() fdb $01e9 disable_pri_draw() fdb $02de draw_y_corner() fdb $02d1 draw_x_corner() fdb $0309 absolute_line() fdb $031d relative_line() fdb $0359 pic_fill() fdb $0211 read_pen_status() fdb $01f4 plot_with_pen() * This code adds the load offsets to the program offsets above * * u00ab = loop counter * L0158 tst L008f,pcr test if we've loaded the offsets already bne L0174 done once leave inc L008f,pcr not done set the flag lda #$0b set our index to 11 sta u00ab stow it in mem since we are going to clobber b leau >L0142,pcr load table head address L016a ldd u002e get load offset set in sierra addd ,u add the load offset std ,u++ and stow it back, bump pointer dec u00ab decrement the index bne L016a ain't done go again L0174 rts we're out of here * The interaction between render_pic and pic_cmd_loop is divided * differently in the NAGI source pic_render.c * render_pic() * 4 = proirity and color = F, so the note says * so the priority is MSnibble and the color is LSnibble L0175 ldd #$4f4f load the color pshs d push it on the stack for the pass lbsr L040e call sbuff_fill routine leas $02,s reset stack to value at entry ldd $02,s pull the next word pshs d push it on top of the stack lbsr L0189 call pic_cmd_loop() leas $02,s once we return clean up stack again rts return * pic_cmd_loop() (pic_render.c) * * u005a = color * u005b = sbuff_drawmask * u006b = pen_status L0189 pshs y bsr L0158 ensure load offset has been added to table address lbsr L06fc sbuff_fill() clra make a zero sta u005b sbuff_drawmask sta u006b pen_status coma make the complement FF sta u005a store color ldu 4,s get the word passed in to us on the stack ldd 5,u pull out the required info for the mmu twiddle lbsr L0074 twiddle mmu * pic_cmd_loop() (pic_render.c) starts here ldx X0551 given_pic_data set in pic_res.c L01a2 lda ,x+ pic_byte L01a4 cmpa #$ff if it's FF were done beq L01b9 so head out suba #cmd_start first valid cmd = F0 so subtract to get index blo L01a2 less than F0 ignore it get next byte cmpa #$0a check for top end bhi L01a2 greater than FA ignore it get next byte leau >L0142,pcr load the addr of the dispatch table asla sign extend multiply by two for double byte offset jsr [a,u] make the call bra L01a4 loop again L01b9 puls y done then fetch the y back rts and return * Command $F0 change picture color and enable picture draw * enable_pic_draw() pic_render.c * differs slightly with pic_render.c * does't have colour_render() * and setting of colour_picpart * * u005a = color * u005b = sbuff_drawmask * * x contains pointer to given_pic_data known as the pic_byte * after ldd * a contains color * b contains draw mask * returns the next pic_byte in a L01bc ldd u005a pulls in color and sbuff_drawmask anda #$f0 and color with $F0 ora ,x+ or that result with the pic_byte and bump to next orb #$0f or the sbuff_drawmask with $0F std u005a store the updated values lda ,x+ return value ignored so this just bumps to next pic_byte rts * Command $F1 Disable picture draw * disable_pic_draw() * * u005a = color * u005b = sbuff_drawmask * x contains pointer to given_pic_data known as the pic_byte * after ldd * a contains color * b contains draw mask * returns the next pic_byte in a L01c9 ldd u005a pulls in color and sbuff_drawmask ora #$0f ors color with $0F (white ??) andb #$f0 ands draw mask with $F0 std u005a store the updated values lda ,x+ return value ignored so this just bumps to next pic_byte rts * Command $F2 Changes priority color and enables priority draw * enable_pri_draw() pic_render.c * * u005a = color * u005b = sbuff_drawmask * x contains pointer to given_pic_data known as the pic_byte * after ldd * a contains color * b contains draw mask * returns the next pic_byte in a L01d4 ldd u005a pulls in color and sbuff_drawmask anda #$0f ands color with $0F sta u005a save color lda ,x+ loads pic_byte and bumps to next asla times 2 with sign extend asla again times 2 asla and again times 2 asla end result is multiply pic_byte by 16 ($10) ora u005a or that value with the modified color orb #$f0 or the sbuff_drawmask with $F0 std u005a store the updated values lda ,x+ return value ignored so this just bumps to next pic_byte rts * Command $F3 Disable priority draw * diasable_pri_draw() pic_render.c * * u005a = color * u005b = sbuff_drawmask * x contains pointer to given_pic_data known as the pic_byte * after ldd * a contains color * b contains draw mask * returns the next pic_byte in a L1e9 ldd u005a pulls in color and sbuff_drawmask ora #$f0 or the color with $F0 andb #$0f and the sbuff_drawmask with $0F std u005a store the updated values lda ,x+ return value ignored so this just bumps to next pic_byte rts * Command $FA plot with pen * Logic is pic_byte >= 0xF0 in c source. * Emailed Nick Sonneveld 3/14/ 03 * * u006b = pen_status * u00a2 = pen_x position * u00a3 = pen_y position * u00a6 = texture_num * * x contains pointer to given_pic_data known as the pic_byte * returns the next pic_byte in a * plot_with_pen() (pic_render.c) L01f4 lda u006b pen_status bita #$20 and but don't change check for pen type solid or splater ($20) beq L0204 is splater lda ,x+ load pic_byte (acca) from pic_code and bump pointer cmpa #cmd_start test against $F0 if a is less than * based on discussions with Nick this must have been a bug * in the earlier versions of software... * if it is less than $F0 it's just a picture byte * fix next rev. lblo L02ea branch to a return statement miles away (could be fixed) sta u00a6 save our pic_byte in texture_num L0204 lbsr L0364 call read_xy_postion lblo L02ea far off rts std u00a2 pen x/y position bsr L0218 call plot_with_pen2() bra L01f4 go again ... * yes there is no rts here in the c source either * Command $F9 Change pen size and style * read_pen_status() pic_render.c * * u006b = pen_status * * x contains pointer to given_pic_data known as the pic_byte * returns the next pic_byte in a L0211 lda ,x+ get pic_byte sta u006b save as pen_status lda ,x+ return value ignored so this just bumps to next pic_byte rts * plot_with_pen2() * called from plot with pen * Sets up circle_ptr * * u006b = pen_status * u009e = pos_init_x * u009f = pos_init_y * u00a2 = pen_x position * u00a3 = pen_y position * u00a4 = pen_final_x * u00a5 = pen_final_y * u00a7 = pen.size * u00a8 = t * u00a9 = pensize x 2 * u00aa = " * u00ab = scratch var * u00ac = scratch var * u00ad = penwidth * u00ae = " L0218 ldb u006b pen_status andb #$07 stb u00a7 pen.size ?? save for pen_status & $07 clra clear a and condition codes lslb multiply by 2 std u00a9 pen size x 2 leau L0132,pcr circle_list[] ldd b,u d now holds one of the circle_list values leau L00b0,pcr circle_data[] leau d,u use that to index to a circle_data item * u now is circle_ptr * Set up x position clra ldb u00a2 load pen_x position lslb multiply by two rola subb u00a7 subtract the pen.size bcc L023f outcome not less than zero move on deca bpl L023f if we still have pos must be 0 or > ldd #0000 bra L024d L023f std u00ab store pen_x at scratch ldd #$0140 start with 320 subd u00a9 subtract 2 x pen.size cmpd u00ab pen_x to calc bls L024d if pen_x is greater keep temp calc ldd u00ab otherwise use pen_x L024d lsra divide by 2 rorb stb u00a2 stow at pen_x stb u00a4 stow at pen_final_x * Set up y position lda u00a3 pen_y suba u00a7 pen.size bcc L025c >= 0 Ok go stow it clra otherwise less than zero so set it to 0 bra L0268 go stow it L025c sta u00ab store pen_y at scratch lda #y_max start with 167 suba u00aa subtract 2 x pen.size cmpa u00ab compare to pen_y calced so far bls L0268 if pen_y > calc use calc and save it lda u00ab otherwise use pen_y L0268 sta u00a3 pen_y sta u00a5 pen_final_y lda u00a6 texture_num ora #$01 sta u00a8 t ?? ldb u00aa 2 x pen.size incb bump it by one tfr b,a copy b into a adda u00a5 add value to pen_final_y sta u00a5 save new pen_final_y lslb shift b left (multiply by 2) leax L0090,pcr binary list[] ldd b,x use 2x pensize + 1 to index into list std u00ad pen width ??? * this looks like it should have been nested for loops * but not coded that way in pic_render.c * new y L0284 leax L0090,pcr binary_list[] * new x L0288 lda u006b pen_status bita #O_UPDATE and it with $10 but don't change bne L0298 not equal zero go on to next pen status test ldd ,u otherwise load data at circle_ptr anda ,x and that with first element in binary_list bne L0298 if thats not zero go on to next pen status check andb $01,x and the second bytes of data at circle_ptr * and binary_list beq L02ba that outcome is equ zero head for next calcs L0298 lda u006b pen_status bita #$20 anded with $20 but don't change beq L02af equals zero set up and plot buffer lda u00a8 otherwise load t (texture_num | $01) lsra divide by 2 bcc L02a5 no remainder save that number as t eora #$b8 exclusive or t with $B8 L02a5 sta u00a8 save new t bita #O_DRAWN anded with 1 but don't change bne L02ba not equal zero don't plot bita #O_BLKIGNORE anded with 2 but don't change beq L02ba does equal zero don't plot L02af pshs u save current u sbuff_plot uses it ldd u00a2 load pen_x/pen_y values std u009e save at pos_init_x/y positions lbsr L046f head for sbuff_plot() puls u retrieve u from before call L02ba inc u00a2 increment pen_x value leax $04,x move four bytes in the binary_list cmpx u00ad comapre that value to pen_width bls L0288 less or same go again leau $02,u bump circle_ptr to next location in circle_data[] lda u00a4 load pen_final_x sta u00a2 store at pen_x inc u00a3 bump pen_y lda u00a3 pen_y cmpa u00a5 compare to pen_final_y bne L0284 not equal go do the next row rts * Command $F5 Draw an X corner * draw_x_corner() pic_render.c * * u009e = pos_init_x * u009f = pos_init_y L02d1 lbsr L0364 call read_xy_pos bcs L02ea next subs rts std u009e save pos_init_x/y positions lbsr L046f head for sbuff_plot() bsr L02eb draw_corner(0) rts * Command $F4 Draw a Y corner * draw_y_corner() pic_render.c * * u009e = pos_init_x * u009f = pos_init_y L02de lbsr L0364 call read_xy_pos bcs L02ea return std u009e save at pos_init_x/y positions lbsr L046f head for sbuff_plot() bsr L02f9 draw_corner(1) L02ea rts * draw_corner(u8 type) pic_render.c * * u009e = pos_init_x * u009f = pos_init_y * u00a0 = pos_final_x * u00a1 = pos_final_y draw_x: L02eb lbsr L036f get_x_pos() bcs L02ea prior subs return sta u00a0 store as pos_final_x ldb u009f load pos_init_y stb u00a1 store as pos_final_y lbsr L0421 call sbuff_xline() draw_y: L02f9 lbsr L0381 get_y_pos bcs L02ea prior subs return stb u00a1 save pos_final_y lda u009e load pos_init_x sta u00a0 save pos_final_x lbsr L0447 sbuff_yline() bra L02eb head for draw_x * Command $F6 Absolute line * absolute_line() * This command is before Draw X corner in nagi source * * u009e = pos_init_x * u009f = pos_init_y * u00a0 = pos_final_x * u00a1 = pos_final_y L0309 bsr L0364 call read_xy_pos bcs L02ea prior subs return std u009e save at pos_init_x/y positions lbsr L046f head for sbuff_plot() L0312 bsr L0364 call read_xy_pos bcs L02ea prior subs return std u00a0 save at pos_final_x/y and passed draw_line in d lbsr L0394 call draw_line() bra L0312 go again * relative_line() * * u009e = pos_init_x * u009f = pos_init_y * u00a0 = pos_final_x * u00a1 = pos_final_y L031D bsr L0364 call read_xy_pos bcs L02ea prior subs return std u009e save at pos_init_x/y positions lbsr L046f head for sbuff_plot() * calc x L0326 lda ,x+ get next pic_byte * and load it in pos_data in c source cmpa #cmd_start is that equal $F0 or greater bcc L02ea yep were done so return (we use prior subs return ??) * that rascal in acca changes names again to x_step * but it's still the same old data anda #$70 and that with $70 * (where these values are derived from I haven't a clue, as of yet :-)) lsra divide by 2 lsra and again lsra once more lsra and finally another for a /16 ldb -$01,x get the original value bpl L0337 if original value not negative move on nega else it was so flip the sign of the computed value L0337 adda u009e add pos_init_x position cmpa #x_max compare to 159 bls L033f if it's less or same move on lda #x_max else cap it at 159 L033f sta u00a0 store as pos_final_x * calc y * not quite the same as pic_render.c almost * we've go the pic_byte ... er pos_data ... now called y_step * in b so lets calc the y_step andb #$0f and with $0F (not in pic_render.c) bitb #$08 and that with $08 but don't change beq L034a if result = 0 move on andb #$07 else and it with $07 negb and negate it L034a addb u009f add calced value to pos_init_y cmpb #y_max compare to 167 bls L0352 less or same move on ldb #y_max greater ? cap it L0352 stb u00a1 pos_final_y * passes pos_final_x/y in d lbsr L0394 call draw_line() bra L0326 go again exit is conditinals inside loop * Command $F8 Fill * pic_fill() * * u009e = pos_init_x * u009f = pos_init_y L0359 bsr L0364 call read_xy_pos bcs L02ea returned a 1 head for prior subs return std u009e save at pos_init_x/y position lbsr L0486 call sbuff_picfill() bra L0359 loop till we get a 1 back from read_xy_pos * read_xy_pos() L0364 lbsr L036f go get x position lblo L02ea prior subs return lbsr L0381 go get the y position rts * get_x_pos() L036f lda ,x+ load pic_byte cmpa #cmd_start is it a command? bhs L037e if so set CC cmpa #x_max compare to 159 bls L037b is it less or same clear CC and return lda #x_max greater than load acca with 159 L037b andcc #$fe clear CC ad return rts L037e orcc #1 returns a "1" rts * get_y_pos() L0381 ldb ,x+ load pic_byte cmpb #cmd_start is it a command blo L038b nope less than command lda -$01,x was a command load x back in acca bra L037e go set CC L038b cmpb #y_max compare to 167 bls L0391 is it less or same clear CC and return ldb #y_max greater than load accb with 167 L0391 andcc #$fe clear CC and return rts * draw_line() pic_render.c * while this is a void function() seems pos_final_x/y are passed in d * * u009e = pos_init_x * u009f = pos_init_y * u00a0 = pos_final_x * u00a1 = pos_final_y * u00a2 = x_count * u00a3 = y_count * u00a4 = pos_x * u00a5 = pos_y * u00a6 = line_x_inc * u00a7 = line_y_inc * u00a8 = x_component * u00a9 = y_component * u00aa = largest_line * u00ab = counter * process straight lines L0394 cmpb u009f compare pos_final_y with pos_init_y lbeq L0421 if equal call sbuff_xline() and don't return here cmpa u009e else compare with pos_init_x position lbeq L0447 if equal call sbuff_yline() and don't return here ldd u009e load pos_init_x/y positions std u00a4 store at pen_final ??? not in pic_render.c version * process y lda #$01 line_y_inc ldb u00a1 load pos_final_y subb u009f subtract pos_init_y bcc L03ae greater or equal zero don't negate * less than zero nega flip the sign of line_y_inc negb flip the sign of y_component L03ae sta u00a7 store line_y_inc stb u00a9 store y_component * process x lda #$01 line_x_inc ldb u00a0 load pos_final_x subb u009e subtract pos_init_x bcc L03bc greater or equal zero don't negate * less than zero nega flip the sign of line_x_inc negb flip the sign of x_component L03bc sta u00a6 store line_x_inc stb u00a8 store x_component * compare x/y components cmpb u00a9 compare y_component to x_component blo L03d0 if x_component is smaller move on * x >= y * x_component is in b stb u00ab counter stb u00aa largest_line lsrb divide by 2 stb u00a3 store y_count clra make a zero sta u00a2 store x_count bra L03dc move on * x < y L03d0 lda u00a9 load y_component sta u00ab stow as counter sta u00aa stow as largest line lsra divide by 2 sta u00a2 store x_count clrb make a zero stb u00a3 store as y_count * loops through the line and uses sbuff_plot to do the screen write * y_count is in b L03dc addb u00a9 add in the y_component stb u00a3 and stow back as y_count cmpb u00aa compare that with line_largest blo L03ee if y_count >= line_largest is not the case branch subb u00aa subtract line_largest stb u00a3 store as y_count ldb u00a5 load pos_y addb u00a7 add line_y_inc stb u00a5 stow as pos_y * x_count is in a L03ee adda u00a8 add in x_component sta u00a2 store as x_count cmpa u00aa compare that with line_largest blo L0400 if x_count >= line_largest is not the case branch suba u00aa subtract line_longest sta u00a2 store at x_count lda u00a4 load pos_x adda u00a6 add line_x_inc sta u00a4 stow as pos_x L0400 ldd u00a4 load computed pos_x/y std u009e store at pos_init_x/y positions lbsr L046f head for sbuff_plot() ldd u00a2 reload x/y_count dec u00ab decrement counter bne L03dc if counter not zero go again rts *********************************************************************** * sbuff_fill() sbuf_util.c * fill color is passed in s register L040e pshs x save x as we use it for an index ldu #gbuffend address to write to ldx #picb_size $6900 bytes to write (26.25K) * this would be picture buffer width x height ldd $04,s since we pushed x pull our color input out of the stack L0418 std ,--u store them and dec dest address leax -$02,x dec counter bne L0418 loop till done puls x fetch the x rts return * sbuff_xline() sbuff_util.c * gets called here with pos_final_x/y in accd * * u005a = color * u005b = sbuff_drawmask * u009e = pos_init_x * u009f = pos_init_y * u00a0 = pos_final_x * u00a1 = pos_final_y * u00ac = x_orig L0421 sta u00ac stow as x_orig cmpa u009e compare with pos_init_x position bhs L042d if pos_final_x same or greater branch * otherwise init > final so swap init and final ldb u009e load pos_init_x position stb u00a0 save pos_final_x position sta u009e save pos_init_x position L042d bsr L046f head for sbuff_plot() returns pointer in u ldb u00a0 load pos_final_x subb u009e subtract pos_init_x position beq L0442 if they are the same move on * b now holds the loop counter len * u is the pointer returned from sbuff_plot leau $01,u bump the pointer one byte right L0437 lda ,u get the the byte ora u005b or it with sbuff_drawmmask anda u005a and it with the color sta ,u+ save it back and bump u to next byte decb decrememnt the loop counter bne L0437 done them all? Nope loop L0442 lda u00ac x_orig (pos_final_x) sta u009e save at pos_init_x position rts * sbuff_yline() sbuf_util.c * gets called here with pos_final_x/y in accd * * u005a = color * u005b = sbuff_drawmask * u009e = pos_init_x * u009f = pos_init_y * u00a0 = pos_final_x * u00a1 = pos_final_y * u00ac = y_orig L0447 stb u00ac stow as y_orig cmpb u009f compare with pos_init_y bhs L0453 if pos_final same or greater branch * otherwise init > final so swap 'em lda u009f load pos_init_y sta u00a1 stow as pos_final_y stb u009f stow as pos_init_y L0453 bsr L046f head for sbuff_plot() returns pointer in u ldb u00a1 load pos_final_y subb u009f subtract pos_init_y beq L046a if they are the same move on * b now holds the loop counter len * u is the pointer returned from sbuff_plot L045b leau PICBUFF_WIDTH,u bump ptr one line up lda ,u get the byte ora u005b or it with sbuff_drawmmask anda u005a and it with the color sta ,u save it back out decb decrement the loop counter bne L045b done them all ? Nope loop L046a ldb u00ac load y_orig stb u009f save it as pos_init_y rts * sbuff_plot() from sbuf_util.c * according to agi.h PBUF_MULT(width) ((( (width)<<2) + (width))<<5) * which next 3 lines equate to so the $A0 is from 2 x 5 * pointer is returned in index reg u * * u005a = color * u005b = sbuff_drawmask * u009e = pos_init_x * u009f = pos_init_y L046f ldb u009f load pos_init_y lda #$A0 according to PBUF_MULT() mul do the math addb u009e add pos_init_x position adca #0000 this adds the carry bit in to a addd #gfx_picbuff add that to the start of the screen buf $6040 tfr d,u move this into u lda ,u get the byte u points to ora u005b or it with sbuff_drawmask anda u005a and it with the color sta ,u and stow it back at the same place rts return * sbuff_picfill(u8 ypos, u8 xpos) sbuf_util.c * u005a = color * u005b = sbuff_drawmask * u009e = pos_init_x * u009f = pos_init_y * u00a0 = left * u00a1 = right * u00a2 = old_direction * u00a3 = direction * u00a4 = old_initx * u00a5 = old_inity * u00a6 = old_left * u00a7 = old_right * u00a8 = stack_left * u00a9 = stack_right * u00aa = toggle * u00ab = old_toggle * u00ae = color_bl * u00af = mask_dl * u00b0 = old_buff (word) * u00b2 = temp (buff) colorbl set $4F temp_stk set $E000 L0486 pshs x save x ldx #temp_stk load addr to create a new stack sts ,--x store current stack pointer there and decrement x tfr x,s make that the stack * s is now stack_ptr pointing to fill_stack ldb u009f pos_init_y lda #$a0 set up PBUF_MULT mul do the math addb u009e add pos_init_x adca #0000 add in that carry bit addd #gfx_picbuff add the start of screen buffer $6040 tfr d,u move this to u * u now is pointer to screen buffer b ldb u005a load color lda u005b load sbuff_drawmask * next 2 lines must have been a if (sbuff_drawmask > 0) * not in the nagi source lbeq L05f5 if sbuff_drawmask = 0 we're done bpl L04b8 if not negative branch to test color cmpa #cmd_start comp $F0 with sbuff_drawmask bne L04b8 not = go test color for $0F andb #$f0 and color with $F0 cmpb #$40 compare that to $40 (input was $4x) lbeq L05f5 if so were done lda #$f0 set up value for mask_dl bra L04c2 go save it L04b8 andb #$0f and color with $0F cmpb #$0f was it already $0F lbeq L05f5 if so we're done lda #$0f set up value for mask_dl L04c2 sta u00af stow as mask_dl anda #colorbl and that with $4F sta u00ae stow that as color_bl lda ,u get byte at screen buffer anda u00af and with mask_dl cmpa u00ae compare to color_bl lbne L05f5 not equal were done ldd #$FFFF push 7 $FF bytes on temp stack pshs a,b and set stack_ptr accordingly pshs a,b pshs a,b pshs a lda #$a1 load a with 161 sta u00a0 stow it at left clra make a zero sta u00a1 stow it at right sta u00aa stow it at toggle inca now we want a 1 sta u00a3 stow it at direction * fill a new line L04e9 ldd u00a0 load left/right std u00a6 stow at old_left/right lda u00aa load toggle sta u00ab stow at old_toggle ldb u009e load pos_init_x stb u00a4 store as old_initx incb accb now becomes counter stu u00b0 stow current screen byte as old_buff L04f8 lda ,u get the screen byte pointed to by u ora u005b or it with sbuff_drawmmask anda u005a and that with the color sta ,u stow that back lda ,-u get the screen byte befor that one anda u00af and that with mask_dl cmpa u00ae compare result with color_bl bne L050b not equal move on decb otherwise decrement the counter bne L04f8 if were not at zero go again L050b leau 1,u since cranked to zero bump the screen pointer by one tfr u,d move that into d subd u00b0 subtract old_buff addb u009e add pos_init_x stb u00a0 stow at left lda u009e load pos_init_x stb u009e store left at pos_init_x stu u00b2 temp buff ldu u00b0 load old_buff leau 1,u bump to the next byte nega negate pos_init_x value adda #x_max add that to 159 (subtract pos_init_x) beq L0537 that's the new counter and if zero move on L0524 ldb ,u get that screen byte (color_old) andb u00af and it with mask_dl cmpb u00ae check against color_bl bne L0537 not equal move on ldb ,u load that byte again to do something with orb u005b or it with sbuff_drawmmask andb u005a and it with color stb ,u+ stow it back and bump the pointer deca decrement the counter bne L0524 if we haven't hit zero go again L0537 tfr u,d move the screen buff ptr to d subd u00b2 subtract that saved old pointer decb sunbtract a 1 addb u00a0 add in the left stb u00a1 store as the right lda u00a6 load old_left cmpa #$a1 compare to 161 beq L0577 if it is move on cmpb u00a7 if the new right == old right beq L0552 then move on bhi L0566 not equal and right > old_right * otherwise stb u00a4 stow right as old_initx clr u00aa clear toggle bra L056c head for next calc * they were equal L0552 lda u00a0 load a with left cmpa u00a6 compare that to old_left bne L0566 move on lda #$01 set up a one cmpa u00aa compare toggle beq L0577 is a one ? go to locnext sta u00aa not one ? set it to 1 lda u00a1 load right sta u00a4 stow it as old_initx bra L056c head for the next calc * right > old_right or left > old left L0566 clr u00aa clear toggle lda u00a7 load old right sta u00a4 save as old_initx * push a bunch on our temp stack L056c ldy u00a2 old_direction/direction ldx u00a4 old_initx/y ldu u00a6 old_left/right lda u00ab old_toggle pshs a,x,y,u push them on the stack locnext: L0577 lda u00a3 load direction sta u00a2 stow as old_direction ldb u009f load pos_init_y stb u00a5 stow as old_inity L057f addb u00a3 add direction to pos_init_y stb u009f stow the updated pos_init_y cmpb #y_max compare that to 167 bhi L05c5 greater than 167 go test direction L0587 ldb u009f load pos_init_y lda #$A0 according to PBUF_MULT mul do the math addb u009e add pos_init_x position adca #0000 this adds the carry bit into the answer addd #gfx_picbuff add that to the screen buff start addr $6040 tfr d,u move it into u lda ,u get the byte pointed to anda u00af and with mask_dl cmpa u00ae compare with color_bl lbeq L04e9 if equal go fill a new line lda u009e load pos_init_x ldb u00a3 load direction cmpb u00a2 compare to old_direction beq L05bc go comapre pos_init_x and right tst u00aa test toggle bne L05bc not zero go comapre pos_init_x and right cmpa u00a8 compare pos_init_x and stack_left blo L05bc less than stack_left go comapre pos_init_x and right cmpa u00a9 compare it to stack_right bhi L05bc greater than go comapre pos_init_x and right lda u00a9 load stack_right cmpa u00a1 compare to right bhs L05c5 greater or equal go check direction inca add one to stack_right sta u009e stow as pos_init_x L05bc cmpa u00a1 compare updated value to right bhs L05c5 go check directions inca less than then increment by 1 sta u009e stow updated value pos_init_x bra L0587 loop for next byte * test direction and toggle L05c5 lda u00a3 load direction cmpa u00a2 compare old_direction bne L05dc not equal go pull stacked values tst u00aa test toggle bne L05dc not zero go pull stack values nega negate direction sta u00a3 store back at direction lda u00a0 load left sta u009e stow as pos_init_x ldb u00a5 load old_inity stb u009f stow at pos_init_y bra L05ef go grab off stack and move on * directions not equal L05dc puls a,x,y,u grab the stuff off the stack cmpa #$FF test toggle for $FF source has test of pos_init_y beq L05f5 equal ? clean up stack and return sty u00a2 stow old_direction/direction stx u009e stow pos_init_x/y stu u00a0 stow left/right sta u00aa stow toggle ldb u009f load pos_init_y stb u00a5 stow old_inity L05ef ldx $05,s gets left right off stack stx u00a8 stow stack_left/right bra L057f always loop L05f5 lds ,s reset stack puls x retrieve our x rts return * this routine effective swaps postion of * the two nibbles of the byte loaded * and returns it to the screen * it is the workhorse loop in gfx_picbuff_update gfx.c ??? * called via remap call in mnln gfx_picbuff_update_remap L05fb ldx #gfx_picbuff starting low address of srceen mem L05fe lda ,x get the first byte bit order 0,1,2,3,4,5,6,7 clrb empty b lsra shift one bit from a rorb into b lsra again rorb lsra and again rorb lsra and finally once more rorb stb ,x were changing x anyway so use it for temp storage ora ,x or that with acca so now bit order from orig * is 4,5,6,7,0,1,2,3 sta ,x+ put it back at x and go for the next one cmpx #gbuffend ending high address of screen mem bcs L05fe rts * our blit_struct is a bit different from the one in nagi * * struct blit_struct * { * struct blit_struct *prev; // 0-1 * struct blit_struct *next; // 2-3 * struct view_struct *v; // 4-5 * s8 x; // 6 * s8 y; // 7 * s8 x_size; // 8 * s8 y_size; // 9 * u16 *buffer; // A-B * u16 *view_data // C-D info for mmu twiddler * * }; * blitlist_draw(BLIT *b) obj_base.c L0615 leas -$02,s make room on the stack ldx $04,s get the blit_struct pointer ldu $02,x load u with pointer to next blit L061b stu ,s stow it on the stack beq L0637 if it's zero we're done pshs u push the pointer on the stack lbsr L09d8 call blit_save() leas $02,s get the pointer back in s ldu ,s put it in u ldu $04,u get the pointer to view_struct pshs u push that on the stack and lbsr L07be call obj_blit() leas $02,s get the pointer back in s ldu ,s put it in u ldu $02,u get the pointer to the next one bra L061b and go again L0637 leas $02,s clean up stack and leave rts * blitlist_erase(BLIT *b) obj_base.c * nagi has a return blitlist_free at the end L063a leas -$02,s make room on the stack ldx $04,s get the blit_struct pointer ldu ,x load u with the prev pointer beq L0651 if it's zero we're done L0642 stu ,s stow it on the stack pshs u push the pointer lbsr L0a0f call blit_restore() leas $02,s get the pointer back in s ldx ,s load x with the pointer ldu ,x get the prev from that struct bne L0642 loop again L0651 leas $02,s clean up stack and leave rts * From obj_picbuff.c the pri_table[172] * ours is only 168 pri_table L0654 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 fcb $00,$00,$00,$00,$00,$00 * loops thru 48 bytes with a = 4 * bumps a by one load b with 12 this * iterates thru ten sets of twelve bytes * bumping acca by one as it goes. * table_init() obj_pic_buff.c L06fc leax L0654,pcr point to data block ldb #$30 load index 48 lda #4 load acca = 4 L0704 sta ,x+ save a in buffer decb dec the inner loop counter bne L0704 go again if loop not finished cmpa #$0e get here when inner loop is done bcc L0712 did we do 10 loops (e-4) inca nope bump data byte ldb #$0c set new counter on loops 2-10 * to do 12 bytes and bra L0704 have at it again L0712 rts * obj_chk_control(VIEW *x) obj_picbuff.c * our index reg x points to the view structure * are 3 = x, 4 = y instead of 3-4 = x & 5-6 = y ??? * This routine is passed a pointer to a view_structure * from agi.h in the nagi source * struct view_struct *{ * u8 step_time; // 0 * u8 step_count; // 1 // counts down until the next step * u8 num; // 2 * s16 x; // 3-4 in nagi * s16 y; // 5-6 in nagi * u8 x; // 3 in ours * u8 y: // 4 the rest of the offsets hold true * u8 dummy1 // 5 who knows what these are * u8 dummy2 // 6 maybe just fillers * u8 view_cur; // 7 * u8 *view_data; // 8-9 * * u8 loop_cur; // A * u8 loop_total; // B * u8 *loop_data; // C-D * * u8 cel_cur; // E * u8 cel_total; // F * u8 *cel_data; // 10-11 * u8 cel_prev_width; // new ones added to prevent kq4 crashing * u8 cel_prev_height; * //u8 *cel_data_prev;// 12-13 * BLIT *blit; // 14-15 * * s16 x_prev; // 16-17 * s16 y_prev; // 18-19 * s16 x_size; // 1A-1B * s16 y_size; // 1C-1D * u8 step_size; // 1E * u8 cycle_time; // 1F * u8 cycle_count; // 20 // counts down till next cycle * u8 direction; // 21 * u8 motion; // 22 * u8 cycle; // 23 * u8 priority; // 24 * u16 flags; // 25-26 * * //u8 unknown27; // 27 // these variables depend on the motion * //u8 unknown28; // 28 // type set by follow ego, move, obj.. stuff * //u8 unknown29; // 29 // like that * //u8 unknown2A; // 2A * * union * { * struct // move_ego move_obj * { * s16 x; // 27 * s16 y; // 28 * u8 step_size; // 29 // original stepsize * u8 flag; // 2A * } move; * * struct // follow_ego * { * u8 step_size; // 27 * u8 flag; // 28 * u8 count; // 29 * } follow; * * // wander * u8 wander_count; // 27 * * // reverse or end of loop * u8 loop_flag; // 27 * }; *}; *typedef struct view_struct VIEW; * u00a5 = flag_signal * u00a6 = flag_water * u005c = flag_control * * X01af is loaction of state.flag * see agi.h for definition of state structure L0713 pshs y save y ldx $04,s sets up mmu info ldd $08,x load view_data passed to mmu twiddler lbsr L0074 twiddle mmu ldb $04,x load y lda $26,x load flags bita #O_PRIFIXED and with $04 but don't change bne L072f not zero move on * it is zero then leau L0654,pcr load buffer address clra clear a since we will use d as an index lda d,u fetch the data from pri_table sta $24,x save as priority L072f lda #$A0 set up PBUF_MULT() mul do the math addb $03,x add in x adca #0000 add in the carry bit addd #gfx_picbuff add it to the start of the screen buff addr 6040 tfr d,u move the pointer pb to u ldy $10,x load y with cel_data ptr clra make a zero sta u00a6 stow it at flag_water sta u00a5 stow it at flag_signal inca make a 1 sta u005c stow it at flag_contro1 ldb $24,x load priority cmpb #$0F compare it with 15 beq L078b If it equals 15 move on * otherwise if not equal 15 sta u00a6 stow that 1 at flag_water ldb ,y cx first byte of cel_data (cel_width) * do while cx != 0 L0752 lda ,u+ (pri) put byte at pb in acca and bump pointer anda #$F0 and that with $F0 (obstacle ??) beq L077a if it equals 0 set flag_control =0 and check_finish cmpa #$30 compare pri to 48 (water ??) beq L0766 not equal move to end of loop clr u00a6 clear the water flag cmpa #$10 compare it with 16 (conditional ??) beq L077e if equal go test for observe blocks cmpa #$20 compare with 32 beq L0787 L0766 decb decrement cx bne L0752 not zero yet loop again lda $25,x load flags in acca tst u00a6 test flag_water bne L0776 not zero next test bita #O_DRAWN should be O_WATER Looks like a BUG in ours beq L078b if it equals one head for check_finish bra L077a clear that flag control first and leave L0776 bita #O_HRZNIGNORE should be O_LAND Looks like a BUG in ours beq L078b L077a clr u005c clear flag_control bra L078b head for check_finish L077e lda $26,x load flags in acca bita #O_BLKIGNORE and with $02 but don't change beq L077a equals zero clear flag_control and go check_finish bra L0766 then head back in the loop L0787 sta u00a5 store acca at flag signal (obj_picbuff.c has =1) bra L0766 continue with loop L078b lda $02,x load num bne L07bb if not zero were done head out * flag signal test lda u00a5 load flag_signal * operates on F03_EGOSIGNAL beq L079d if its zero go reset the signal * otherwise set the flag lda X01af load the state.flag element ora #$10 set the bits sta X01af save it back bra L07a5 go test the water flag L079d lda X01af load the state.flag element anda #$ef reset the bits sta X01af save it back * flag_water test L07a5 lda u00a6 load flag_water beq L07b3 if zero go reset the flag * otherwise set it lda X01af load the state.flag element ora #$80 set the bits sta X01af save it back bra L07bb baby we're out of here L07b3 lda X01af load the state.flag element anda #$7f reset the bits sta X01af save it back L07bb puls y retrieve our y and leave rts * obj_blit(VIEW *v) obj_blit.c * our index reg x points to the view structure * are 3 = x, 4 = y instead of 3-4 = x & 5-6 = y ??? * u00a2 = cel_height * u00a7 = cel_trans * u00a8 = init (pb) * u00ac = cel_invis * u00ad = pb_pri * u009e = view_pri * u009f = col L07be ldx $02,s pull our x pointer off the stack ldd $08,x load d with view_data lbsr L0074 twiddle mmu ldu $10,x u now is a pointer to cel_data lda $02,u cel_data[$02] loaded bita #O_Block are we testing against a block or does $80 mean something else here? beq L07d1 if zero skip next instruction lbsr L087f otherwise call obj_cell_mirror L07d1 ldd ,u++ load the first 2 bytes of cel_data and bump to next word * cel_width is in acca we ignore stb u00a2 save as cel_height * obj_blit.c has and $0F which is a divide by 16 * we do a multiply x 16 ??? lda ,u+ cel_trans asla asla asla asla sta u00a7 save as cel_tran lda $24,x priority asla shift left 4 asla asla asla sta u009e view_pri ldb $04,x load the y value subb u00a2 subtract the cel_height incb add 1 lda #$a0 set up PBUF_MULT() mul do the math addb $03,x add in the x value adca #0000 add in the carry from multiply addd #gfx_picbuff add this to the start of the screen buff addr $6040 std u00a8 pb pointer to the pic buffer ldx u00a8 load it in an index reg lda #$01 sta u00ac set cel_invis to 1 and save bra L0800 L07ff abx bump the pb pointer L0800 lda ,u+ get the next "chunk" beq L082d if zero ldb -$01,u not zero load the same byte in accb anda #$f0 and chunk with $F0 (col) andb #$0f and chunk with $0F (chunk_len) cmpa u00a7 compare with cel_trans beq L07ff set up and go again color is trasnparent lsra shift right 4 lsra lsra lsra sta u009f save the color L0814 lda ,x get the byte pointed to by pb anda #$f0 get the priority portion cmpa #$20 compare to $20 bls L083b less or equal cmpa u009e compare to view_pri bhi L085b pb_pri > view_pri * otherwise lda u009e load view_pri L0822 ora u009f or it with col sta ,x+ store that at pb and bump the pointer clr u00ac zero cel_invis decb decrement chunk_len bne L0814 not equal zero go again inner loop bra L0800 go again outer loop L082d dec u00a2 decrement cel_height beq L0862 equal zero move on out of cel_height loop ldx u00a8 load init leax >PICBUFF_WIDTH,x move 160 into screen stx u00a8 stow that back as init/pb bra L0800 go again L083b stx u00ad save the pointer clra set up ch L083e cmpx #blit_end compare to gfx_picbuff+$6860 bhs L084f not less than then branch out * less than the end leax >PICBUFF_WIDTH,x bump the pointer by 160 lda ,x get that byte anda #$f0 and it with $F0 cmpa #$20 test against $20 bls L083e less or equal go again L084f ldx u00ad load pb_pri cmpa u009e compare with view_pri bhi L085b pb_pri > view_pri lda ,x make the next anda #$f0 pb_pri bra L0822 go or it with the color L085b leax $01,x bump the pb pointer decb decrement chunk_len bne L0814 not equal do middle loop again bra L0800 go again L0862 ldx $02,s pull our view pointer back off the stack lda $02,x get the num bne L087e if not zero exit routine lda u00ac get the cel_invis value beq L0876 reset the flag * set the flag lda X01af load the state.flag ora #$40 set it sta X01af stow it back bra L087e exit routine * reset the flag L0876 lda X01af load state.flag anda #$bf clear it sta X01af stow it L087e rts * obj_cel_mirror(View *v) in obj_picbuff.c * we use different values from those shown nagi files * on entry * a contains cell_data[$02] in call from obj_blit() * x contains pointer to view data * u contains pointer to cel_data * * saves and restores x,y,u regs on exit * * u00a1 = width * u00a2 = height_count * u00a7 = trans transparent color left shifted 4 * u00aa = tran_size ?? * u00ab = meat_size * u00af = loop_cur << 4 * u00b0 = al L087f anda #$30 and that with $30 (nagi has $70) lsra shift right 4 lsra lsra lsra cmpa $0A,x compare that with loop_cur lbeq L0926 if equal we're done pshs x,y,u save our view (x) what ever (y) and cel_data (u) pointers lda $0A,x load loop_cur asla and shift it 4 left asla asla asla sta u00af stow it as ?? lda #$cf load a with with $CF (nagi has $8F) anda $02,u and that with cel[2] ora u00af or with loop_cur<<4 sta $02,u stow it back at cel[2] ldy #gbuffend ldd ,u++ load d with width and hieght std u00a1 stow that lda ,u+ load a with trans color asla and shift left 4 asla asla asla sta u00a7 stow as trans stu u00b0 stow u as al L08af clrb make a zero stb u00ab stow it as meat_size * nagi code has tran_size set to width and * al&$0F subtracted from it. * in this loop L08b2 stb u00aa and tran_size lda ,u+ load in the next cel_data byte beq L08fc if its a zero leave loop ldb -$01,u otherwise fetch the same data into b * at this point a & b both have the same data byte anda #$f0 and the a copy with $F0 andb #$0f and the b copy with $0F cmpa u00a7 compare byte&$F0 with trans bne L08cc not equal branch out of loop addb u00aa otherwise add in tran_size bra L08b2 and loop L08c6 ldb ,u+ load the nbext byte and bump the pointer beq L08d4 if it was zero move on andb #$0f otherwise and it with $0F L08cc addb u00aa add in tran_size stb u00aa save it as tran_size inc u00ab bump meat_size bra L08c6 loop to the next byte L08d4 lda u00aa load tran_size nega negate it adda u00a1 add in the width beq L08f1 if that is zero move on L08db suba #$0f subtract 15 from it bls L08eb less or same move on sta u00aa otherwise stow that back as tran_size lda u00a7 fetch trans ora #$0f or it with 15 sta ,y+ store it at buff (gbuffend) and bump pointer lda u00aa fetch tra_size bra L08db loop again L08eb adda #$0f add 15 back into a (tran_size) ora u00a7 or that with trans sta ,y+ stow that at buff and bump the pointer L08f1 leax -$01,u set x to the last cel_data byte processed ldb u00ab load b with the meat_size (the loop counter) L08f5 lda ,-x copy from the cel_data end sta ,y+ to the buff front decb dec the counter bne L08f5 not done loop again L08fc stb ,y+ on entry b should always = 0 stow that at the next buff location dec u00a2 decrement the height_count bne L08af not zero go again * now we are going to copy the backward temp buffer back to the cel tfr y,d get the buff pointer in d subd #gbuffend subtract the starting value of the buffer stb u00b2 save that as the buffer size andb #$fe make it an even number tfr d,x transfer that to x ldu u00b0 al cel_data pointer ldy #gbuffend load y start of our temp buffer L0913 ldd ,y++ get a word std ,u++ stow a word leax -$02,x dec the counter by a word bne L0913 not zero go again * so we've moved an even number of bytes lda u00b2 load the actual byte count lsra divide by 2 bcc L0924 no remainder (not odd) we're done lda ,y otherwise move the last sta ,u byte L0924 puls x,y,u retrieve our x,y,u values L0926 rts and return to caller * obj_add_pic_pri(VIEW *v) obj_picbuff.c * our index reg x points to the view structure * * u009e = priority&$F0 * u00a3 = pri_table[y] * u00a4 = pri_table[y] * u00a8 = pb (word) * u00a9 = " * u00b3 = pri_height/height L0927 pshs y save the y ldx $04,s get the the pointer to our view ldd $08,x load d with view_data ? lbsr L0074 twiddle mmu * set up d as pointer to pri_table value clra zero a ldb $04,x load view y value leau L0654,pcr load pri_table address lda d,u fetch the pri_table y data std u00a3 stow it in a temp ldb $24,x load priority andb #$0f and that with $0F bne L0948 if that equals zero move on ora $24,x otherwise or the pri_table[y] with priority sta $24,x stow that back as priority L0948 pshs x push the pointer to the view on the stack lbsr L07be call obj_blit() leas $02,s reset the stack ldx $04,s get the pointer to our view lda $24,x load priority cmpa #$3F compare to $3F lbhi L09d5 if greater then nothing to do head out leau L0654,pcr load pri_table address ldb u00a4 fetch pri_table[y] (cx) clr u00b3 clear pri_height L0962 clra zero acca inc u00b3 bump pri_hieght tstb is pri_table[y] beq L096f equal zero if so move on decb dec our counter cx lda d,u load pri_table[cx] cmpa u00a3 compare to pri_table[y] beq L0962 if they are equal loop again * set up and execute PBUF_MULT call L096f ldb $04,x load the view->y in lda #$a0 from pbuf mult mul do the math addb $03,x add in the x value adca #0000 add in the carry addd #gfx_picbuff add in the base address $6040 tfr d,u move that to an index reg (pb) stu u00a8 stow it as pb ldy $10,x load y with cel_data pointer ldb $01,y get the second byte (height) cmpb u00b3 compare to pri_height bhi L098b greater move on stb u00b3 otherwise save the largest as pri_height L098b lda $24,x load the priority again anda #$f0 and it with $F0 sta u009e stow that for later use * bottom line ldb ,y load b with the first byte in cel_data (cx) L0994 lda ,u get the byte at our pic buff pb anda #$0f and it with $0F ora u009e or it with priority&F0 sta ,u+ stow it back and bump the pointer decb dec the loop counter cx bne L0994 not zero go again * it has a height dec u00b3 test "height" for > 1 beq L09d5 wasn't head no more to do so head out ldu u00a8 reset u to our pb pic buff pointer * the sides ldb ,y get the first byte of cel_data decb subtract 1 (sideoff) L09a8 leau -$A0,u decrement pb by 160 tfr u,x move that value into x lda ,u get the data anda #$0f and it with $0F ora u009e or it priority&$F0 sta ,u stow it back clra zero a so we can use d as a pointer lda d,u use "sideoff" as an index into pb anda #$0f and that with $0F ora u009e or that rascal with priority&$F0 abx add that value to our x pointer sta ,x and store it there dec u00b3 dec the height bne L09a8 greater than zero go again * the top of the box ldb ,y get the cel_data first byte in b subb #$02 subtract 2 leau $01,u bump the pb pointer L09ca lda ,u grab the byte anda #$0f and that with $0F ora u009e or it with priority &$F0 sta ,u+ stow it back and bump the pointer decb dec our counter bne L09ca loop if not finished L09d5 puls y return the y value rts return * blit_save(BLIT *b) obj_blit.c * our blit_struct is a bit different from the one in nagi * * u00a0 = zeroed and never changed cause we use the next byte :-) * u00a1 = x_count (x_size) when cmpx ha ha * u00a2 = y_count (y_size) * u00a8 = pic buffer start pic_cur * u00ad = pic_cur + offset L09d8 ldu $02,s get the pointer to the blit_struct ldd $0C,u get the pointer to the view_data for mmu twiddler lbsr L0074 twiddle mmu ldu $02,s get the pointer to the blit_struct data back in u ldd $08,u load the x/y_size std u00a1 stow that at x/y_count clr u00a0 zero some adder ldb $07,u get the y value lda #$a0 set up PBUF_MULT mul do the math addb $06,u add in x adca #0 add in the carry bit addd #gfx_picbuff add in pic buff base $6040 ldu $0A,u load u with with the buffer pointer blit_cur L09f5 std u00a8 save the buffer start pointer pic_cur addd u00a0 add in the offset x_size std u00ad stow that at pic_cur + offset ldx u00a8 load x with pic_cur L09fd ldd ,x++ copy 2 bytes at a time std ,u++ to the buffer at blit_cur cmpx u00ad have we copied it all ?? blo L09fd nope loop again ldd u00a8 load with pic buffer start addd #PICBUFF_WIDTH add 160 dec u00a2 dec y_count bne L09f5 not zero loop again rts * blit_restore(BLIT *b) obj_blit.c * blit_save(BLIT *b) obj_blit.c * our blit_struct is a bit different from the one in nagi * * u00a0 = zeroed and never changed cause we use the next byte :-) * u00a1 = x_count (x_size) when cmpx ha ha * u00a2 = y_count (y_size) * u00a8 = pic buffer start pic_cur * u00ad = pic_cur + offset L0a0f ldu $02,s get the pointer to the blit structure ldd $0C,u lbsr L0074 twiddle mmu ldu $02,s get the blit_structure back in u ldd $08,u load x/y_size std u00a1 stow them at x/y_count clr u00a0 clear the byte prior to x_size ldb $07,u get the y value lda #$a0 set up PBUF_MULT mul do the math addb $06,u add in the x value adca #0 add in the carry bit addd #gfx_picbuff add in the base address $6040 ldu $0A,u load u with buffer pointer blit_cur L0a2c std u00a8 save the screen start buffer pic_cur addd u00a0 add in the x_size std u00ad stow at pic_cur + offset ldx u00a8 load x pic_cur pointer L0a34 ldd ,u++ grab em from the buffer std ,x++ and send them to the screen cmpx u00ad moved them all ?? blo L0a34 nope then keep on keeping on ldd u00a8 load the pic_cur pointer addd #PICBUFF_WIDTH add 160 dec u00a2 dec the y count bne L0a2c not zero move some more rts fcb $00,$00,$00,$00 fcb $00,$00,$00,$00 fcc "shdw" fcb $00 emod eom equ * end