![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chaser.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / demos / apps / chaser|
Return to chaser.c CVS log | Up to [OS/2 SDKs] / os2sdk / demos / apps / chaser |
1.1 root 1: /* SWARM - the idea behind this game is as follows:
2: *
3: * You have a collection of objects in the center of the playing field
4: * that you are trying to protect (just one object in current version). You
5: * control your own movements with the mouse. A number of "chasers" start
6: * around the edges of the field and begin moving towards the objects
7: * you want to protect. If you move the mouse on top of a chaser and click
8: * the left button, the chaser will be killed and disappear from the screen.
9: * But as you close in on the chaser, it will detect your presence and try
10: * to dodge you. Meanwhile the other chasers will continue to go after
11: * your objects. If one of the chasers reaches an object, it will begin
12: * dragging it away to the edge of the screen (currently the game just
13: * ends when the single object is reached). When all objects are dragged
14: * away, the game ends. If a chaser is killed while dragging an object, the
15: * object is left where it is and must be protected in place - player cannot
16: * move objects. If you kill all the chasers, a new group of faster ones
17: * will be spawned (currently the speed is constant). Your score is how
18: * many chasers you can kill (no score currently kept), so there is no
19: * advantage in sitting on the object for long periods.
20: *
21: * Swarm demonstrates several capabilities of OS/2 and the philosphy behind
22: * them. This program is made of three components: Initialization, the
23: * mouse driven thread and the attacker thread. The attacker thread is
24: * launched as many times as there are attackers in a game. Launching
25: * the attacker several times takes full advantage of the OS to schedule
26: * resources. The programmer can think of the problem as only one attacker.
27: * The system handles multiple instances of the thread.
28: *
29: * As the main loop launched threads it puts an ID code into the threads
30: * stack. The code is used to index into the universe data.
31: *
32: * A ram semaphore is used to control access to global data.
33: *
34: * This demonstration shows the use of the following OS/2 system calls:
35: *
36: * Tasking: VIO API: Mouse API:
37: *
38: * DOSSEMREQUEST() VIOSCROLLUP() MOUOPEN()
39: * DOSSEMCLEAR() VIOWRTCELLSTR() MOUSETPTRPOS()
40: * DOSCREATETHREAD() VIOSETCURTYPE() MOUREADEVENTQUE()
41: * DOSEXIT() VIOSETMODE()
42: * DOSSLEEP()
43: */
44: #include <malloc.h>
45: #include <stdio.h>
46: #include <doscalls.h>
47: #include <subcalls.h>
48:
49: #define STACKSIZE 200
50:
51: #define DANGERZONE 3
52:
53: #define LONGNAP 500L
54: #define SHORTNAP 150L
55:
56: #define WAIT (-1L) /* Wait for ram Semaphore */
57:
58: #define CHASER 8 /* Number of chasers */
59:
60: #define SCREEN_HEIGHT 24 /* Default screen size */
61: #define SCREEN_WIDTH 79
62:
63: #define GOAL univ[CHASER] /* Macros for constant stuff */
64: #define ME univ[ID]
65: #define MOUSE univ[CHASER+1]
66:
67: #define ALIVE 1 /* Flags for attackers/goal */
68: #define DEAD 0
69:
70: char Chaser[2] = { 0xE8, 0x20 }; /* character and attribute */
71: char Prize[2] = { 0x03, 0x2C }; /* for our various objects */
72: char Blank[2] = { 0x20, 0x22 };
73: char Blood[2] = { 0x20, 0x44 };
74:
75: struct { /* Universe structure and array */
76: int row; /* univ[0] = chaser */
77: int col; /* univ[n-1] = chaser */
78: int state; /* univ[n] = GOAL */
79: } univ[CHASER+1]; /* univ[n+1]= MOUSE */
80:
81: short ScreenHeight, /* Screen attributes */
82: ScreenWidth;
83:
84: unsigned short Mouse; /* place for mouse handle */
85: unsigned long Shortnap; /* Sleep times for chasers */
86: unsigned long Longnap;
87: unsigned long far Semaphore = 0; /* Ram semaphore */
88:
89: struct CursorData NewCur; /* struct for setting cursor type */
90: struct CursorData OldCur;
91:
92: struct ModeData modedata; /* Data saves for VIO mode */
93: struct ModeData OldVioMode;
94:
95: /*
96: * Define all procedures before main.
97: */
98: void Defender();
99: void CleanUp();
100: int InitGame();
101: void chaserthread();
102: int ParseCmdLine(int,char **);
103:
104: /*
105: * main(ac,av)
106: *
107: * Top level procedure and MOUSE thread for the GAME demo.
108: */
109: int main(ac, av)
110: int ac;
111: char *av[];
112: {
113: /*
114: * Parse the command line and perform some initialization.
115: */
116: if (ParseCmdLine(ac,av)) {
117: printf("usage: %s [24|43] [F|M|S]\n",av[0]);
118: DOSEXIT(0,1);
119: }
120: if (InitGame()) /* Init game, exit if some problem */
121: DOSEXIT(1,1);
122:
123: Defender(); /* Run mouse loop (defend against the swarm */
124:
125: CleanUp();
126: }
127:
128: /*
129: * Defender()
130: *
131: * This is the main loop of the mouse control thread.
132: *
133: * The semaphore is used to prevent the other threads from time slicing
134: * while this routine is examining and/or modifying the universe. The
135: * Semaphore is grabbed after the read of the Mouse queue so we don't tie
136: * up the attackers while waiting for a mouse event.
137: */
138: void Defender()
139: {
140: unsigned ReadType = 1, /* Wait for mouse events */
141: alive,
142: i;
143: struct EventInfo MouInfo; /* mouse event packet structure */
144:
145: alive = CHASER;
146:
147: do {
148: MOUREADEVENTQUE( (struct EventInfo far *)&MouInfo,
149: (unsigned far *)&ReadType,
150: Mouse ); /* read where mouse is */
151:
152: DOSSEMREQUEST((unsigned long)&Semaphore, WAIT);
153:
154: if( MouInfo.Mask & 1) { /* If the mouse has moved */
155: MOUSE.row = MouInfo.Row;
156: MOUSE.col = MouInfo.Col;
157: }
158: if( MouInfo.Mask & 4 ) { /* if left button pressed, */
159: for (i = 0; i < CHASER; i++ ) {
160: if( ( MOUSE.row == univ[i].row ) &&
161: ( MOUSE.col == univ[i].col ) && /* see if we hit one */
162: ( univ[i].state == ALIVE) ) {
163: univ[i].state = DEAD;
164:
165: DOSBEEP(300,75); /* make a dying sound */
166: DOSBEEP(600,75);
167: DOSBEEP(300,85);
168:
169: alive--; /* Decrease number of alive */
170: break; /* Can only kill one at a time */
171: }
172: }
173: }
174: if( MouInfo.Mask & 16 ) /* If right button pressed... */
175: break; /* End game, clean up */
176:
177: DOSSEMCLEAR((unsigned long)&Semaphore);
178: }
179: while (GOAL.state == ALIVE && alive); /* loop till all are dead */
180: }
181:
182: /*
183: * This thread manages the individule attackers. It is spun off as
184: * many times as needed for a game.
185: *
186: * The interaction of the mouse cursor and the chaser character is sort
187: * of funny, hence the funny code, below. The mouse cursor seems to
188: * remember what was under it when it was written. Hence we cannot erase
189: * the chaser if the mouse is "sitting" on it. If we do, then when the
190: * mouse moves it will re-write the original object. This shows up as
191: * phantom chasers.
192: */
193: void far chasethread(ID) /* code that controls each "chaser" */
194: int ID;
195: {
196: short row, col; /* Our current position */
197: short deltaX, deltaY; /* how far from the mouse are we? */
198: short danger; /* flag to indicate not far enough! */
199: short m; /* general purpose indexes */
200:
201:
202: /* Print out the initial chaser character */
203:
204: VIOWRTCELLSTR( (char far *)Chaser, 2, ME.row, ME.col, 0 );
205:
206: /*
207: * Keep running as long as the goal and myself haven't been killed.
208: */
209: for (;;) {
210:
211: row = ME.row; /* Grab the current position */
212: col = ME.col;
213: /*
214: * If mouse is sitting upon the chaser, do nothing. Allow
215: * the player some time to kill the chaser
216: */
217: if ((MOUSE.row == row) && (MOUSE.col == col)) {
218: DOSSLEEP( 1L );
219: continue;
220: }
221: DOSSEMREQUEST((unsigned long)&Semaphore, WAIT);
222: /*
223: * If either the GOAL or Myself is dead, exit loop and clean up.
224: * This wasn't tested in the for loop since we don't want to exit
225: * if the MOUSE is sitting on the chaser.
226: */
227: if (ME.state != ALIVE || GOAL.state != ALIVE)
228: break;
229:
230: deltaX = MOUSE.col - col; /* calculate how far we are */
231: deltaY = MOUSE.row - row;
232:
233: if (((deltaX < -DANGERZONE) || (DANGERZONE < deltaX)) ||
234: ((deltaY < -DANGERZONE) || (DANGERZONE < deltaY))) {
235:
236: danger = 0;
237:
238: if(GOAL.row < row) /* Creep towards the GOAL */
239: row--;
240: else if (GOAL.row > row)
241: row++;
242: if(GOAL.col < col)
243: col--;
244: else if(GOAL.col > col)
245: col++;
246: }
247: else {
248: danger = 1; /* Run away from the mouse */
249:
250: if ((MOUSE.row > row) && (row > 0))
251: row--;
252: else if ((MOUSE.row < row) && (row < ScreenHeight))
253: row++;
254: if ((MOUSE.col > col) && (col < ScreenWidth))
255: col--;
256: else if ((MOUSE.col < col) && (col > 0))
257: col++;
258: }
259: /*
260: * A quick and Dirty hack to prevent chasers from merging
261: */
262: for (m = 0; m < CHASER; m++ ) {
263: if (univ[m].state == ALIVE &&
264: univ[m].row == row &&
265: univ[m].col == col &&
266: m != ID) {
267: row += 1;
268: col += 3;
269: }
270: }
271: /*
272: * Zap the old chaser and print the new. Release the semaphore
273: * after this, there can be no undesirable interactions now.
274: */
275: VIOWRTCELLSTR( (char far *)Blank, 2, ME.row, ME.col, 0 );
276: VIOWRTCELLSTR( (char far *)Chaser, 2, row, col, 0 );
277:
278: DOSSEMCLEAR((unsigned long)&Semaphore);
279: /*
280: * Update the current location
281: */
282: ME.row = row;
283: ME.col = col;
284: /*
285: * See if we have reached the GOAL, if so eat it and exit
286: */
287: if ((row == GOAL.row) && (col == GOAL.col)) {
288: VIOWRTCELLSTR( (char far *)Blank, 2, row, col, 0 );
289: DOSBEEP(600,175);
290: DOSBEEP(1200,175); /* if we reach the prize, let out a yell */
291: DOSBEEP(600,185); /* paint the screen red and end the game */
292: DOSBEEP(1200,175);
293: VIOSCROLLUP( 0, 0, -1, -1, -1, (char far *)Blood, 0 );
294: GOAL.state = DEAD;
295: }
296: /*
297: * Sleep an amount of time that varies depending
298: * upon the danger level
299: */
300: if( danger )
301: DOSSLEEP(Shortnap);
302: else
303: DOSSLEEP(Longnap);
304:
305: }
306: /*
307: * chaser is now dead or the game is over.
308: * Erase its body and terminate the thread. Release the semaphore.
309: */
310: DOSSEMCLEAR((unsigned long)&Semaphore);
311:
312: if (GOAL.state == ALIVE) {
313: VIOWRTCELLSTR( (char far *)Blank, 2, ME.row, ME.col, 0 );
314: }
315: DOSEXIT(0,0);
316: }
317:
318: /*
319: * InitGame()
320: *
321: * Initialize the GOAL, MOUSE and the CHASERS, launch each chase thread.
322: *
323: * Returns an error if any internal processing errors
324: */
325: int InitGame()
326: {
327: struct PtrLoc InitMouPos;
328: void far chasethread(); /* code to control chasers */
329: unsigned far *Tstack; /* stack for new threads */
330: unsigned chaseID;
331: int i, rc;
332: /*
333: * Clear the screen.
334: */
335: VIOSCROLLUP( 0, 0, -1, -1, -1, (char far *)Blank, 0 );
336: /*
337: * Draw the prize
338: */
339: GOAL.row = ScreenHeight/2;
340: GOAL.col = ScreenWidth /2;
341: GOAL.state = ALIVE;
342: VIOWRTCELLSTR((char far *)Prize, 2, GOAL.row, GOAL.col, 0 );
343: /*
344: * Open the mouse pointer device and set it's location.
345: */
346: MOUOPEN( 0L, (unsigned far *)&Mouse );
347: InitMouPos.RowPos = GOAL.row;
348: InitMouPos.ColPos = GOAL.col;
349: MOUSETPTRPOS((struct PtrLoc far *)&InitMouPos, Mouse);
350: MOUDRAWPTR(Mouse);
351: /*
352: * A simple minded initialization for the start of each chaser.
353: * Some sort of random placement (based upon system time?) would
354: * be nice.
355: */
356: univ[0].row = 0; univ[0].col = 0;
357: univ[1].row = 0; univ[1].col = 25;
358: univ[2].row = 0; univ[2].col = 55;
359: univ[3].row = 0; univ[3].col = 79;
360: univ[4].row = ScreenHeight; univ[4].col = 0;
361: univ[5].row = ScreenHeight; univ[5].col = 25;
362: univ[6].row = ScreenHeight; univ[6].col = 55;
363: univ[7].row = ScreenHeight; univ[7].col = 79;
364: /*
365: * Grab the semaphore to prevent chaser from running until we are done.
366: */
367: DOSSEMREQUEST((unsigned long)&Semaphore, WAIT);
368:
369: for( i = 0; i < CHASER; i++ ) { /* for each of our threads... */
370: univ[i].state = ALIVE; /* Set each one alive */
371: Tstack = (int *)malloc(sizeof(int) * STACKSIZE);
372: if (Tstack == NULL ) { /* Create a stack */
373: printf( "thread %d stack malloc failed\n", i );
374: return(1);
375: }
376: Tstack += STACKSIZE; /* set stack pointer to correct end */
377: *--Tstack = i; /* Push the ID on as a parameter */
378:
379: rc = DOSCREATETHREAD(chasethread, (unsigned far *)&chaseID,
380: (char far *)Tstack);
381: if(rc) {
382: printf( "create of thread %d failed, error: %d\n", i, rc );
383: return (1);
384: }
385: }
386: DOSSEMCLEAR((unsigned long)&Semaphore);
387:
388: return (0);
389: }
390:
391: /*
392: * CleanUp()
393: *
394: * Routine to reset the Video modes back to where they were.
395: * (As best as possible).
396: */
397: void CleanUp()
398: {
399: char blank[2];
400:
401: DOSSLEEP(1L); /* Yeild the machine so attacker can clean up */
402: VIOSETMODE((struct ModeData far *)&OldVioMode, 0);
403: /*
404: blank[0] = ' ';
405: blank[1] = OldVioMode.color;
406: VIOSCROLLUP( 0, 0, -1, -1, -1, (char far *)blank, 0 );
407: */
408: VIOSETCURTYPE(&OldCur, 0);
409: DOSEXIT(1,0); /* Exit and terminate all threads. */
410: }
411:
412: /*
413: * ParseCmdLine(ac, av)
414: *
415: * Parses the command line arguments and sets up the game accordingly
416: *
417: */
418: int ParseCmdLine(ac,av)
419: int ac;
420: char **av;
421: {
422: struct ModeData modedata;
423: int VioMode;
424:
425: Longnap = LONGNAP;
426: Shortnap = SHORTNAP;
427: ScreenWidth = SCREEN_WIDTH;
428: ScreenHeight = SCREEN_HEIGHT;
429: VioMode = 25;
430:
431: while(--ac) {
432: av++;
433: switch(**av) {
434: case 'f':
435: case 'F':
436: Longnap = LONGNAP / 2;
437: Shortnap= SHORTNAP/ 2;
438: break;
439: case 'm':
440: case 'M':
441: Longnap = LONGNAP;
442: Shortnap= SHORTNAP;
443: break;
444: case 's':
445: case 'S':
446: Longnap = LONGNAP * 2;
447: Shortnap= SHORTNAP* 2;
448: break;
449: case '4': /* Assume 43 line mode was wanted */
450: ScreenHeight = 42;
451: ScreenWidth = 79;
452: VioMode = 43;
453: break;
454: case '2':
455: ScreenHeight = 24;
456: ScreenWidth = 79;
457: VioMode = 25;
458: break;
459: default:
460: return(1);
461: }
462: }
463:
464: VIOGETCURTYPE(&OldCur, 0); /* Save old cursor */
465:
466: modedata.length = sizeof(modedata); /* change mode as needed */
467: VIOGETMODE((struct ModeData far *)&modedata, 0);
468: OldVioMode = modedata;
469: modedata.row = VioMode;
470: VIOSETMODE((struct ModeData far *)&modedata, 0);
471:
472: NewCur.cur_start = 0;
473: NewCur.cur_end = 0;
474: NewCur.cur_width = 1;
475: NewCur.cur_attribute = -1;
476:
477: VIOSETCURTYPE(&NewCur, 0 ); /* make cursor go away */
478:
479: return (0);
480: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.