![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to life2.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / demos / apps / life|
Return to life2.asm CVS log | Up to [OS/2 SDKs] / os2sdk / demos / apps / life |
1.1 root 1: ;*** life2.asm - assembler routines for life.c
2: ;*
3: ;* Contains: _draw_grid - draws 79x45 grid on screen
4: ;* _dostep - advances the internal and screen grids
5: ;* one generation
6: ;* scrfill - private screen routine for _dostep
7: ;* scrremove - private screen routine for _dostep
8: ;*
9:
10:
11: ;*** segment definitions for the link with C
12: ;
13: _TEXT SEGMENT BYTE PUBLIC 'CODE'
14: _TEXT ENDS
15: _DATA SEGMENT WORD PUBLIC 'DATA'
16: _DATA ENDS
17: CONST SEGMENT WORD PUBLIC 'CONST'
18: CONST ENDS
19: _BSS SEGMENT WORD PUBLIC 'BSS'
20: _BSS ENDS
21: DGROUP GROUP CONST, _BSS, _DATA
22: ASSUME CS: _TEXT, DS: DGROUP, SS: DGROUP, ES: DGROUP
23:
24: ;*** the public routines
25: ;
26: PUBLIC _draw_grid, _dostep
27:
28:
29: ;*** Global variables from LIFE.C
30: ;
31: EXTRN _ScrSeg:WORD
32: EXTRN _ScrCol:WORD
33: EXTRN _ScrRow:WORD
34:
35: ;*** OS/2 functions
36: ;
37: EXTRN VIOSCRUNLOCK:FAR
38: EXTRN VIOSCRLOCK:FAR
39:
40:
41: _TEXT SEGMENT
42: ;*** _draw_grid - clears screen and draws 79x45 grid
43: ;*
44: ;* Entry: ds:_ScrSeg - screen buffer segment, from life.c
45: ;*
46: ;* Exit: None
47: ;*
48: _draw_grid PROC NEAR
49: push bp ; startup
50: mov bp,sp
51: sub sp,2 ; one word variable for VIOSCRLOCK
52: push di ; save register used by C compiler
53:
54: ; get screen access
55: mov ax,1
56: push ax ; wait until screen available
57: lea ax,byte ptr [bp-2]
58: push ss
59: push ax ; far address of return code
60: sub ax,ax
61: push ax ; reserved word
62: call VIOSCRLOCK ; call DOS for access
63:
64: ; get parameter and set up
65: mov es,ds:_ScrSeg ; (es) = screen buffer segment
66: xor di,di ; (di) = offset in screen (start at 0)
67:
68: ; loop to draw 45 rows of the tops and middles of grid squares
69: mov dx,45 ; (dx) = rows of grid squares, counter
70: dg1: mov ax,5555h ; (ax) = alternating bit pattern
71: mov cx,39 ; (cx) = number of full words on a line
72: rep stosw ; fill line with 5555h
73: mov es:[di],al ; finish off last odd byte
74: inc di ; (di) = start of next row
75: inc di
76: mov ax,08080h ; (ax) = left bit on
77: mov cx,40 ; (cx) = number of words on a line
78: rep stosw ; fill next line with f0f0h
79: dec dx ; at screen bottom?
80: jnz dg1 ; if no, loop
81:
82: ; draw the last line
83: mov ax,5555h ; (ax) = alternating bits
84: mov cx,39 ; (cx) = full words on last line
85: rep stosw ; do fill
86: mov es:[di],al ; finish off line with odd byte
87:
88: ; clear bottom on screen on even bit plane
89: inc di ; (di) = start of last few lines
90: sub ax,ax ; (ax) = blank
91: mov cx,400 ; (cx) = words left at bottom
92: rep stosw
93:
94: ; draw the grid lines on the odd bit plane
95: mov di,2000h ; (di) = top of odd bit plane
96: mov ax,08080h ; (ax) = left bit on
97: mov cx,40*2*45 ; (cx) = words to fill
98: rep stosw ; fill remainder with f0f0h
99:
100: ; clear bottom on screen on odd bit plane
101: sub ax,ax ; (ax) = blank
102: mov cx,400 ; (cx) = words left at bottom
103: rep stosw
104:
105: ; return the screen
106: sub ax,ax
107: push ax ; reserved word
108: call VIOSCRUNLOCK ; call DOS to return screen
109:
110: ; return
111: pop di
112: mov sp,bp
113: pop bp
114: ret
115: _draw_grid ENDP
116:
117:
118: ;*** _dostep - advances InGrid one generation.
119: ;*
120: ;* Entry: char far *INGRID - InGrid, main internal bit map of cells
121: ;* char far *INGRID2 - InGrid2, working area of same size
122: ;* unsigned INROW - InRow, bits per row of above to areas
123: ;* unsigned INCOL - InCol, rows of above to areas
124: ;* ds:_ScrSeg - from life.c
125: ;* ds:_ScrRow - from life.c
126: ;* ds:_ScrCol - from life.c
127: ;*
128: ;* Exit: InGrid is updated on generation in accordance with
129: ;* the rules of life.
130: ;* Returns in AX the return code from its VIOSCRLOCK call
131: ;*
132: INGRID EQU [bp+4]
133: INGRID2 EQU [bp+8]
134: INROW EQU [bp+12]
135: INCOL EQU [bp+14]
136:
137: _dostep PROC NEAR
138: push bp
139: mov bp,sp
140: sub sp,2 ; make room for local var
141: push di
142: push si
143: push es
144: push ds
145:
146: ; try to lock screen and put return code in [BP-2]
147: xor ax,ax
148: push ax ; don't wait until screen available
149: lea ax,byte ptr [bp-2]
150: push ss
151: push ax ; far address of return code
152: sub ax,ax
153: push ax ; reserved word
154: call VIOSCRLOCK ; call DOS for access
155:
156: ; get pointers to the two internal grids
157: les di,INGRID2 ; (es:di) = @InGrid2
158: lds si,INGRID ; (ds:si) = @InGrid
159:
160: ; copy InGrid into InGrid2
161: mov ax,INCOL ; (ax) = cells per row
162: mul word ptr INROW ; (ax) = total cells
163: mov cl,4
164: shr ax,cl ; (ax) = cell/16 = total words
165: mov cx,ax ; (cx) = total words
166: rep movsw ; move InGrid into InGrid2
167:
168:
169: ; main step loop
170: ; I use a rather odd algorithm. "neighbors" is defined
171: ; here as all cells in a 3x3 grid summed. If neighbors < 3, the
172: ; the cell in the center is turned off. If neighbors = 3, the cell
173: ; is turned on. If neighbors = 4, the cell is left in its current
174: ; state. If neighbors > 4, the cell is turned off.
175: push ds
176: pop es ; (es) = InGrid's segment
177: lds bx,INGRID2 ; (ds) = InGrid2's segment
178: ; (bx) = pointer to offset in both
179: mov di,INROW ; (di) = row count
180: mov si,INCOL ; (si) = column count
181: shr si,1
182: shr si,1
183: shr si,1 ; (si) = bytes per row in grids
184:
185: ; loop within the grid through all its rows
186: ; here we come when at the start of a row
187: ds1: mov cx,INCOL ; (cx) = column count
188: mov al,80h ; (al) = bit mask for current bit
189: xor dx,dx ; (dh) = #of neighbors 1 col back
190: ; (dl) = #of neighbors at cur col
191:
192: ; get number of neighbors on current row
193: ds2: xor ah,ah ; (ah) = count of neighbors on cur row
194: test ds:[bx],al ; is current bit on?
195: jz ds3 ; if not go on
196: inc ah ; if yes, inc neighbor count
197: ds3: cmp bx,si ; are we on top row
198: jb ds4 ; if yes, don't check above top
199: push bx ; save bx
200: sub bx,si ; backup bx to previous row
201: test ds:[bx],al ; is up a row bit on?
202: pop bx ; restore bx
203: jz ds4 ; if not go on
204: inc ah ; if yes, inc neighbor count
205: ds4: cmp di,1 ; are we on last row?
206: jz ds5 ; if yes, don't read off edge
207: test ds:[bx+si],al ; is bit down a row on?
208: jz ds5 ; if not, go on to final neighbor addin
209: inc ah ; if yes, inc neighbor count
210:
211: ; add up the total number of neighbors and decide what to do
212: ds5: cmp cx,INCOL ; are we at far left?
213: jz ds12 ; if yes, don't affect bits off edge
214: add dh,dl ; (dh) = previous two rows of neighbors
215: add dh,ah ; (dh) = total neighbor count
216: cmp dh,3
217: jb ds6 ; if neighbors <3, turn off the cell
218: je ds9 ; if neighbors = 3, turn on the cell
219: cmp dh,4 ;
220: je ds12 ; if neighbors = 4, do nothing
221:
222: ; turn off the center bit
223: ds6: rol al,1 ; backup to center bit
224: jnc ds7 ; if no overflow, go on
225: dec bx ; else, backup to last byte
226: ds7: test es:[bx],al ; is it already off
227: jz ds8 ; if yes, don't do it again
228: not al ; turn on all bits but one to blank
229: and es:[bx],al ; force off bit in InGrid
230: not al ; restore al
231:
232: pop ds ; (ds) = C's data ptr
233: call scrremove ; turn off on screen
234: push ds ; resave C's data ptr
235: mov ds,[bp+8+2] ; (ds) = seg of InGrid2
236:
237: ds8: ror al,1 ; put back al to foreward bit
238: jnc ds12 ; if no overflow, go to next bit
239: inc bx ; if overflow, restore bx
240: jmp ds12 ; go on to next bitl
241:
242: ; turn on the center bit
243: ds9: rol al,1 ; backup to center bit
244: jnc ds10 ; if no overflow, go on
245: dec bx ; else, backup to last byte
246: ds10: test es:[bx],al ; is it already on?
247: jnz ds11 ; if yes, don't do it again
248: or es:[bx],al ; force on bit in InGrid
249: pop ds ; (ds) = C's data ptr
250: call scrfill ; turn on on screen
251: push ds ; resave C's data ptr
252: mov ds,[bp+8+2] ; (ds) = seg of InGrid2
253: ds11: ror al,1 ; put back al to foreward bit
254: jnc ds12 ; if no overflow, go to next bit
255: inc bx ; if overflow, restore bx
256:
257: ; advance to the next bit
258: ds12: ror al,1 ; (al) mask advances to next bit
259: mov dh,dl ; move done neighbor count
260: mov dl,ah ; move the new neighbor row into bl
261: jnc ds13 ; if still in same byte, jmp
262: inc bx ; if at byte end, advance to next byte
263: ds13: loop ds2 ; loop through rest of bits on line
264:
265:
266: ; at the end of the row
267: dec di ; decrement row count
268: jz dsx ; if at end of grid, goto exit routine
269: jmp ds1 ; if not at bottom, go to next row
270:
271: ; at the end of the grid
272: ; return the screen
273: dsx: cmp byte ptr [bp-2],0 ; is the screen locked?
274: jnz dsx1 ; if not, don't unlock
275:
276: sub ax,ax
277: push ax ; reserved word
278: call VIOSCRUNLOCK ; call DOS to return screen
279:
280: dsx1: xor ah,ah
281: mov al,[bp-2] ; return code from SCRLOCK
282:
283: pop ds
284: pop es
285: pop si
286: pop di
287: mov sp,bp
288: pop bp
289: ret
290: _dostep ENDP
291:
292:
293: ;*** scrfill - fills in a cell on the screen in 79x45 grid
294: ;*
295: ;* Entry: (di) = row number counted from bottom up (InRow-di=row to fill)
296: ;* (cx) = col number from right-1 (InCol-1-cx = col to fill)
297: ;* (ds) = data segment of life.c
298: ;*
299: ;* Exit: None, saves all registers
300: ;*
301: scrfill proc near
302: cmp [bp-2],byte ptr 0 ; is the screen available?
303: jnz sfxx ; if not, exit
304:
305: push es
306: push ax
307: push bx
308: push dx
309:
310: ; get screen pointer
311: mov es,ds:_ScrSeg ; (es) = screen buf segment
312: mov ax,INROW
313: sub ax,di ; (ax) = row
314: cmp ax,ds:_ScrRow ; is it on the screen?
315: jae sfx ; if off, exit
316: mul WORD PTR INCOL ; * InCol
317: shl ax,1 ; * 2
318: mov dx,INCOL
319: sub dx,cx
320: dec dx ; (dx) = col to fill
321: cmp dx,ds:_ScrCol ; is it on the screen?
322: jae sfx ; if off, exit
323: add ax,dx ; + col = scrn offset of cell
324:
325: ; fill in screen cell
326: mov bx,ax ; (es:bx) = far ptr to screen cell
327: mov BYTE PTR es:[bx+2000h],7fh ; first line of cell
328: mov BYTE PTR es:[bx+80],7fh ; second
329: mov BYTE PTR es:[bx+2000h+80],7fh ; third line of cell
330:
331: sfx: pop dx
332: pop bx
333: pop ax
334: pop es
335: sfxx: ret
336: scrfill endp
337:
338:
339: ;*** scrremove - removes a cell on the screen in 79x45 grid
340: ;*
341: ;* Entry: (di) = row number counted from bottom up (InRow-di=row to fill)
342: ;* (cx) = col number from right-1 (InCol-1-cx = col to fill)
343: ;* (ds) = data segment of life.c
344: ;*
345: ;* Exit: None, saves all registers
346: ;*
347: scrremove proc near
348: cmp [bp-2],byte ptr 0 ; is the screen available?
349: jnz srxx ; if not, exit
350:
351: push es
352: push ax
353: push bx
354: push dx
355:
356: ; get screen pointer
357: mov es,ds:_ScrSeg ; (es) = screen buf segment
358: mov ax,INROW
359: sub ax,di ; (ax) = row
360: cmp ax,ds:_ScrRow ; is it on the screen?
361: jae srx ; if off, exit
362: mul WORD PTR INCOL ; * InCol
363: shl ax,1 ; * 2
364: mov dx,INCOL
365: sub dx,cx
366: dec dx ; (dx) = col
367: cmp dx,ds:_ScrCol ; is it on the screen?
368: jae srx ; if off, exit
369: add ax,dx ; + col = scrn offset of cell
370:
371: ; remove screen cell
372: mov bx,ax ; (es:bx) = far ptr to screen cell
373: mov BYTE PTR es:[bx+2000h],80h ; first line of cell
374: mov BYTE PTR es:[bx+80],80h ; second
375: mov BYTE PTR es:[bx+2000h+80],80h ; third line of cell
376:
377: srx: pop dx
378: pop bx
379: pop ax
380: pop es
381: srxx: ret
382: scrremove endp
383:
384: _TEXT ENDS
385: END
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.