Mercurial > hg > Members > koba > t_dandy
annotate state_task.cc @ 42:59b070dd0553
add demo file.
author | koba <koba@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Wed, 12 Jan 2011 00:18:16 +0900 |
parents | 6626e451a09d |
children | 56ef94618a0e |
rev | line source |
---|---|
10 | 1 #include <stdio.h> |
2 #include <stdlib.h> | |
3 #include <SDL.h> | |
4 #include "SDL_opengl.h" | |
5 #include "object.h" | |
6 #include "Character.h" | |
7 #include "Character_state.h" | |
8 #include "tokuten.h" | |
9 #include "collision.h" | |
10 #include "bom.h" | |
11 #include "count2.h" | |
12 #include "sgoex.h" | |
19 | 13 #include "sankaku.h" |
14 #include "tama.h" | |
10 | 15 #include "TaskManager.h" |
16 #include "Func.h" | |
17 #include "property.h" | |
18 #include "state_task.h" | |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
19 #include "ObjectType.h" |
10 | 20 |
19 | 21 extern SpriteTable sptable[DEFOBJ]; |
22 extern TaskManager *tmanager; | |
23 | |
33 | 24 CHARACTER *kyeenemyno = NULL; |
25 CHARACTER *tekino0 = NULL; | |
26 CHARACTER *enemy_part1 = NULL; | |
27 CHARACTER *enemy_part2 = NULL; | |
28 CHARACTER *enemy_part3 = NULL; | |
29 CHARACTER *enemy_part4 = NULL; | |
30 CHARACTER *enemy_part5 = NULL; | |
19 | 31 |
32 //int tekino0; | |
33 | 33 int rinkx = 0; |
34 int rinky = 0; | |
19 | 35 int rinkf1 = 0, rinkf2 = 0; |
36 CHARACTER *asteroiddt[200]; | |
37 int asteroidi = 0; | |
38 int enemyfaste = 0; | |
39 int fastebos = 0; | |
40 | |
38 | 41 int counter = 0; |
42 | |
19 | 43 State state_list[LIST_NUM]; |
44 | |
38 | 45 /* output 0~3 */ |
46 static | |
47 int get_num() | |
48 { | |
49 counter++; | |
50 counter %= 4; | |
51 return counter; | |
52 } | |
36 | 53 |
54 static | |
55 int power_of_two(int input) | |
56 { | |
57 int value = 1; | |
58 | |
59 while ( value < input ) { | |
60 value <<= 1; | |
61 } | |
62 return value; | |
63 } | |
64 | |
65 static void | |
66 ReDefSprite(int number, float w, float h, int color) | |
67 { | |
68 SpriteTable *m = &sptable[number]; | |
69 m->w = w; | |
70 m->h = h; | |
71 m->color = (color & 32); | |
72 m->mx = w / 2; | |
73 m->my = h / 2; | |
74 m->tex_w = power_of_two(m->w); | |
75 m->tex_h = power_of_two(m->h); | |
76 } | |
77 | |
78 | |
30 | 79 static int |
19 | 80 GetStateNum(int task_num) |
81 { | |
82 int num = task_num % LIST_NUM; | |
83 | |
84 return num; | |
85 } | |
86 | |
30 | 87 static void |
19 | 88 SetTaskState(int task_num, CHARACTER *(state)(CHARACTER *chara)) |
89 { | |
90 int num = GetStateNum(task_num); | |
91 | |
92 state_list[num] = state; | |
93 } | |
94 | |
95 void | |
96 initStateList() | |
97 { | |
98 SetTaskState(DELETE_CHARA, delete_chara); | |
99 SetTaskState(STATE0, chara_state0); | |
100 SetTaskState(STATE1, chara_state1); | |
101 SetTaskState(STATE2, chara_state2); | |
25 | 102 SetTaskState(STATE3, chara_state3); |
19 | 103 SetTaskState(STATE4, chara_state4); |
104 SetTaskState(STATE5, chara_state5); | |
105 SetTaskState(STATE6, chara_state6); | |
27 | 106 SetTaskState(STATE7, chara_state7); |
19 | 107 SetTaskState(STATE8, chara_state8); |
108 SetTaskState(STATE9, chara_state9); | |
109 SetTaskState(STATE10, chara_state10); | |
110 SetTaskState(STATE11, chara_state11); | |
111 SetTaskState(STATE12, chara_state12); | |
112 SetTaskState(STATE13, chara_state13); | |
33 | 113 |
19 | 114 SetTaskState(STATE20, chara_state20); |
115 SetTaskState(STATE21, chara_state21); | |
116 SetTaskState(STATE22, chara_state22); | |
117 SetTaskState(STATE23, chara_state23); | |
118 SetTaskState(STATE24, chara_state24); | |
119 SetTaskState(STATE25, chara_state25); | |
120 SetTaskState(STATE26, chara_state26); | |
121 SetTaskState(STATE27, chara_state27); | |
122 SetTaskState(STATE28, chara_state28); | |
123 SetTaskState(STATE29, chara_state29); | |
124 SetTaskState(STATE30, chara_state30); | |
125 SetTaskState(STATE31, chara_state31); | |
126 SetTaskState(STATE32, chara_state32); | |
127 SetTaskState(STATE33, chara_state33); | |
128 SetTaskState(STATE34, chara_state34); | |
129 SetTaskState(STATE35, chara_state35); | |
130 SetTaskState(STATE40, chara_state40); | |
131 SetTaskState(STATE41, chara_state41); | |
35 | 132 |
19 | 133 SetTaskState(STATE400, chara_state400); |
134 SetTaskState(STATE401, chara_state401); | |
135 SetTaskState(STATE402, chara_state402); | |
35 | 136 |
19 | 137 SetTaskState(STATE410, chara_state410); |
138 SetTaskState(STATE411, chara_state411); | |
35 | 139 |
19 | 140 SetTaskState(STATE500, chara_state500); |
141 SetTaskState(STATE501, chara_state501); | |
35 | 142 |
19 | 143 SetTaskState(STATE600, chara_state600); |
144 SetTaskState(STATE601, chara_state601); | |
145 SetTaskState(STATE602, chara_state602); | |
146 } | |
147 | |
148 void | |
149 updateState(SchedTask *s, void *chara, void *arg) | |
150 { | |
151 CHARACTER *p = (CHARACTER*)chara; | |
152 | |
153 int num = GetStateNum(p->task); | |
27 | 154 p->state = state_list[num]; |
19 | 155 } |
156 | |
30 | 157 |
158 void | |
38 | 159 PrintCoordinate(SchedTask *s, void *chara, void *arg) |
160 { | |
161 CHARACTER *p = (CHARACTER*)chara; | |
162 printf("x = %f, y = %f, vx = %f, vy = %f\n",p->x, p->y, p->vx, p->vy); | |
163 | |
164 int num = GetStateNum(p->task); | |
165 p->state = state_list[num]; | |
166 } | |
167 | |
168 | |
169 void | |
34 | 170 freeObject(SchedTask *s, void *chara, void *obj) |
171 { | |
172 free(obj); | |
173 | |
174 CHARACTER *p = (CHARACTER*)chara; | |
38 | 175 // printf("x = %f, y = %f, vx = %f, vy = %f\n",p->x, p->y, p->vx, p->vy); |
176 | |
34 | 177 int num = GetStateNum(p->task); |
178 p->state = state_list[num]; | |
179 } | |
180 | |
181 | |
182 void | |
30 | 183 checkContainer(SchedTask *s, void *chara, void *obj) |
184 { | |
185 CHARACTER *p = (CHARACTER*)chara; | |
186 ObjContainer *new_obj = (ObjContainerPtr)obj; | |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
187 |
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
188 if (new_obj->flag == true) { |
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
189 int length = new_obj->length; |
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
190 |
33 | 191 for (int i=0; i < length; i++) { |
192 ObjDataPtr obj_data = &new_obj->data[i]; | |
193 int type = obj_data->type; | |
194 | |
195 switch (type) { | |
37 | 196 case Boms: |
197 Bom(obj_data->x, obj_data->y); | |
198 break; | |
33 | 199 case Tama: |
200 Puttama(obj_data->tama_type, obj_data->x, obj_data->y); | |
201 break; | |
202 case Enemy: { | |
203 int task_num = GetStateNum(obj_data->task); | |
204 Putenemy(obj_data->charano, obj_data->x, obj_data->y, | |
205 obj_data->vx, obj_data->vy, state_list[task_num]); | |
206 break; | |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
207 } |
33 | 208 case Def: |
36 | 209 ReDefSprite(obj_data->number, obj_data->w, obj_data->h, obj_data->color); |
33 | 210 break; |
211 case DefEx: | |
212 DefSpriteEx(obj_data->number, obj_data->middlex, obj_data->middley); | |
213 break; | |
214 case Put: | |
215 PutSprite(obj_data->zorder, obj_data->x, obj_data->y, obj_data->number); | |
216 break; | |
217 case PutEx: | |
218 PutSpriteEx(obj_data->number, obj_data->x, obj_data->y, | |
219 obj_data->scalex, obj_data->scaley, obj_data->angle); | |
220 break; | |
36 | 221 } |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
222 } |
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
223 } |
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
224 int num = GetStateNum(p->task); |
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
225 p->state = state_list[num]; |
30 | 226 |
227 free(new_obj); | |
228 } | |
229 | |
230 | |
19 | 231 CHARACTER* |
10 | 232 SimpleStateTask(CHARACTER *p) |
233 { | |
19 | 234 int task_num = p->task; |
235 HTaskPtr state_task = tmanager->create_task(task_num); | |
33 | 236 |
30 | 237 state_task->set_inData(0, p, sizeof(CHARACTER)); |
33 | 238 |
30 | 239 state_task->set_outData(0, p, sizeof(CHARACTER)); |
33 | 240 |
19 | 241 state_task->set_post(updateState, (void*)p, NULL); |
10 | 242 state_task->set_cpu(SPE_ANY); |
243 state_task->spawn(); | |
19 | 244 |
245 return p; | |
246 } | |
247 | |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
248 |
19 | 249 CHARACTER* |
38 | 250 FixRandomTask(CHARACTER *p) |
251 { | |
252 int task_num = p->task; | |
253 HTaskPtr state_task = tmanager->create_task(task_num); | |
254 | |
255 state_task->set_param(0, (memaddr)get_num()); | |
256 | |
257 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
258 | |
259 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
260 | |
261 state_task->set_post(PrintCoordinate, (void*)p, NULL); | |
262 state_task->set_cpu(SPE_ANY); | |
263 state_task->spawn(); | |
264 | |
265 return p; | |
266 } | |
267 | |
268 | |
269 CHARACTER* | |
19 | 270 withJikiTask(CHARACTER *p) |
271 { | |
272 int task_num = p->task; | |
273 HTaskPtr state_task = tmanager->create_task(task_num); | |
25 | 274 |
30 | 275 state_task->set_inData(0, p, sizeof(CHARACTER)); |
276 state_task->set_inData(1, &jiki, sizeof(player)); | |
33 | 277 |
30 | 278 state_task->set_outData(0, p, sizeof(CHARACTER)); |
33 | 279 |
19 | 280 state_task->set_post(updateState, (void*)p, NULL); |
33 | 281 state_task->set_cpu(SPE_ANY); |
282 state_task->spawn(); | |
19 | 283 |
33 | 284 return p; |
285 } | |
286 | |
287 | |
288 CHARACTER* | |
289 sendContainerTask(CHARACTER *p) | |
290 { | |
291 int task_num = p->task; | |
292 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
293 HTaskPtr state_task = tmanager->create_task(task_num); | |
294 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
295 obj->flag = false; | |
296 obj->length = 0; | |
297 | |
298 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
299 | |
300 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
301 state_task->set_outData(1, obj, 0); | |
302 | |
38 | 303 state_task->set_post(checkContainer, (void*)p, (void*)obj); |
33 | 304 state_task->set_cpu(SPE_ANY); |
305 state_task->spawn(); | |
306 | |
307 return p; | |
308 } | |
309 | |
310 | |
311 CHARACTER* | |
34 | 312 JikiContainerTask(CHARACTER *p) |
33 | 313 { |
314 int task_num = p->task; | |
315 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
316 HTaskPtr state_task = tmanager->create_task(task_num); | |
317 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
318 obj->flag = false; | |
319 obj->length = 0; | |
320 | |
34 | 321 state_task->set_inData(0, p, sizeof(CHARACTER)); |
322 state_task->set_inData(1, &jiki, sizeof(player)); | |
323 | |
324 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
325 state_task->set_outData(1, obj, 0); | |
326 | |
327 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
328 state_task->set_cpu(SPE_ANY); | |
329 state_task->spawn(); | |
330 | |
331 return p; | |
332 } | |
333 | |
334 | |
335 CHARACTER* | |
336 AsteroidTask(CHARACTER *p) | |
337 { | |
338 asteroiddt[asteroidi] = p; | |
339 | |
340 int task_num = ASTEROID_TASK; | |
341 HTaskPtr state_task = tmanager->create_task(task_num); | |
342 | |
343 state_task->set_param(0, (memaddr)asteroidi); | |
344 | |
345 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
346 | |
347 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
348 | |
349 int array_size = sizeof(CHARACTER)*asteroidi; | |
350 if (array_size > 0) { | |
351 CHARACTER *asteroid_array = (CHARACTER*)tmanager->allocate(array_size); | |
352 for (int i = 0; i < asteroidi; i++) { | |
353 asteroid_array[i] = *asteroiddt[i]; | |
354 } | |
355 state_task->set_inData(1, asteroid_array, array_size); | |
356 state_task->set_post(freeObject, (void*)p, (void*)asteroid_array); | |
357 } else { | |
358 state_task->set_post(updateState, (void*)p, NULL); | |
359 } | |
360 state_task->set_cpu(SPE_ANY); | |
361 state_task->spawn(); | |
38 | 362 |
34 | 363 asteroidi++; |
364 return p; | |
365 } | |
366 | |
367 | |
368 CHARACTER* | |
369 Boss1Task1(CHARACTER *p) | |
370 { | |
371 int task_num = p->task; | |
372 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
373 HTaskPtr state_task = tmanager->create_task(task_num); | |
374 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
375 obj->flag = false; | |
376 obj->length = 0; | |
33 | 377 |
378 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
34 | 379 state_task->set_inData(1, &count, sizeof(int)); |
33 | 380 |
381 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
382 state_task->set_outData(1, &count, sizeof(int)); | |
383 state_task->set_outData(2, obj, 0); | |
384 | |
385 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
386 state_task->set_cpu(SPE_ANY); | |
387 state_task->spawn(); | |
388 | |
389 return p; | |
390 } | |
391 | |
392 | |
393 CHARACTER* | |
34 | 394 Boss1Task2(CHARACTER *p) |
33 | 395 { |
396 int task_num = p->task; | |
397 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
398 HTaskPtr state_task = tmanager->create_task(task_num); | |
399 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
400 obj->flag = false; | |
401 obj->length = 0; | |
402 | |
403 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
34 | 404 state_task->set_inData(1, &count, sizeof(int)); |
33 | 405 |
406 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
407 state_task->set_outData(1, &count, sizeof(int)); | |
408 state_task->set_outData(2, &rinkx, sizeof(int)); | |
409 state_task->set_outData(3, &rinky, sizeof(int)); | |
410 state_task->set_outData(4, obj, 0); | |
411 | |
412 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
19 | 413 state_task->set_cpu(SPE_ANY); |
414 state_task->spawn(); | |
415 | |
416 return p; | |
417 } | |
418 | |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
419 |
19 | 420 CHARACTER* |
34 | 421 Boss1Task3(CHARACTER *p) |
33 | 422 { |
423 int task_num = p->task; | |
424 HTaskPtr state_task = tmanager->create_task(task_num); | |
425 | |
426 state_task->set_param(0, (memaddr)rinkx); | |
427 state_task->set_param(1, (memaddr)rinky); | |
428 | |
429 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
430 | |
431 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
432 state_task->set_outData(1, &rinkf1, sizeof(int)); | |
433 | |
434 state_task->set_post(updateState, (void*)p, NULL); | |
435 state_task->set_cpu(SPE_ANY); | |
436 state_task->spawn(); | |
437 | |
438 return p; | |
439 } | |
440 | |
441 | |
442 CHARACTER* | |
34 | 443 Boss1Task4(CHARACTER *p) |
33 | 444 { |
445 int task_num = p->task; | |
446 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
447 HTaskPtr state_task = tmanager->create_task(task_num); | |
448 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
449 obj->flag = false; | |
450 obj->length = 0; | |
451 | |
452 state_task->set_param(0, (memaddr)rinkf1); | |
453 state_task->set_param(1, (memaddr)count); | |
454 | |
455 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
456 | |
457 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
458 state_task->set_outData(1, &count, sizeof(int)); | |
459 state_task->set_outData(2, obj, 0); | |
460 | |
461 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
462 state_task->set_cpu(SPE_ANY); | |
463 state_task->spawn(); | |
464 | |
465 return p; | |
466 } | |
467 | |
468 | |
469 CHARACTER* | |
34 | 470 Boss1Task5(CHARACTER *p) |
25 | 471 { |
472 int task_num = p->task; | |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
473 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
25 | 474 HTaskPtr state_task = tmanager->create_task(task_num); |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
475 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); |
33 | 476 obj->flag = false; |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
477 obj->length = 0; |
25 | 478 |
33 | 479 state_task->set_param(0, (memaddr)fastebos); |
480 state_task->set_param(1, (memaddr)count); | |
481 state_task->set_param(2, (memaddr)rinkx); | |
482 state_task->set_param(3, (memaddr)rinky); | |
483 | |
484 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
485 state_task->set_inData(1, &jiki, sizeof(player)); | |
486 | |
487 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
488 state_task->set_outData(1, &count, sizeof(int)); | |
489 state_task->set_outData(2, &fastebos, sizeof(int)); | |
490 state_task->set_outData(3, &rinkx, sizeof(int)); | |
491 state_task->set_outData(4, &rinky, sizeof(int)); | |
492 state_task->set_outData(5, &rinkf2, sizeof(int)); | |
493 state_task->set_outData(6, obj, 0); | |
494 | |
495 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
496 state_task->set_cpu(SPE_ANY); | |
497 state_task->spawn(); | |
498 | |
499 return p; | |
500 } | |
501 | |
502 | |
503 CHARACTER* | |
34 | 504 Boss1Task6(CHARACTER *p) |
33 | 505 { |
506 int task_num = p->task; | |
507 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
508 HTaskPtr state_task = tmanager->create_task(task_num); | |
509 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
510 obj->flag = false; | |
511 obj->length = 0; | |
512 | |
513 state_task->set_param(0, (memaddr)rinkx); | |
514 state_task->set_param(1, (memaddr)rinky); | |
34 | 515 state_task->set_param(2, (memaddr)filpcount); |
516 state_task->set_param(3, (memaddr)tekino0->f); | |
517 state_task->set_param(4, (memaddr)count); | |
33 | 518 |
30 | 519 state_task->set_inData(0, p, sizeof(CHARACTER)); |
37 | 520 state_task->set_inData(1, &rinkf2, sizeof(int)); |
33 | 521 |
30 | 522 state_task->set_outData(0, p, sizeof(CHARACTER)); |
33 | 523 state_task->set_outData(1, &count, sizeof(int)); |
37 | 524 state_task->set_outData(2, obj, 0); |
34 | 525 |
526 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
527 state_task->set_cpu(SPE_ANY); | |
528 state_task->spawn(); | |
529 | |
530 return p; | |
531 } | |
532 | |
533 | |
534 CHARACTER* | |
535 Boss2Task1(CHARACTER *p) | |
536 { | |
537 int task_num = p->task; | |
538 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
539 HTaskPtr state_task = tmanager->create_task(task_num); | |
540 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
541 obj->flag = false; | |
542 obj->length = 0; | |
543 | |
544 state_task->set_param(0, (memaddr)enemy_part1->f); | |
545 state_task->set_param(1, (memaddr)enemy_part5->f); | |
38 | 546 state_task->set_param(2, (memaddr)get_num()); |
34 | 547 |
548 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
549 state_task->set_inData(1, &count, sizeof(int)); | |
550 state_task->set_inData(2, &rinkx, sizeof(int)); | |
551 state_task->set_inData(3, &rinkf1, sizeof(int)); | |
552 | |
553 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
554 state_task->set_outData(1, &count, sizeof(int)); | |
555 state_task->set_outData(2, &rinkx, sizeof(int)); | |
556 state_task->set_outData(3, &rinkf1, sizeof(int)); | |
557 state_task->set_outData(4, obj, 0); | |
558 | |
559 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
560 state_task->set_cpu(SPE_ANY); | |
561 state_task->spawn(); | |
562 | |
563 return p; | |
564 } | |
565 | |
566 | |
567 CHARACTER* | |
35 | 568 Boss2Task2(CHARACTER *p, int num1, int num2) |
34 | 569 { |
570 int task_num = p->task; | |
571 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
572 HTaskPtr state_task = tmanager->create_task(task_num); | |
573 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
574 obj->flag = false; | |
575 obj->length = 0; | |
576 | |
35 | 577 state_task->set_param(0, (memaddr)enemy_part1->f); |
578 state_task->set_param(1, (memaddr)enemy_part2->f); | |
579 state_task->set_param(2, (memaddr)enemy_part3->f); | |
580 state_task->set_param(3, (memaddr)enemy_part4->f); | |
581 state_task->set_param(4, (memaddr)enemystate[num1].charano); | |
582 state_task->set_param(5, (memaddr)enemystate[num2].charano); | |
38 | 583 state_task->set_param(6, (memaddr)get_num()); |
34 | 584 |
585 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
586 state_task->set_inData(1, kyeenemyno, sizeof(CHARACTER)); | |
587 state_task->set_inData(2, &count, sizeof(int)); | |
588 state_task->set_inData(3, &rinkf1, sizeof(int)); | |
589 | |
590 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
591 state_task->set_outData(1, &count, sizeof(int)); | |
35 | 592 state_task->set_outData(2, obj, 0); |
593 | |
594 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
595 state_task->set_cpu(SPE_ANY); | |
596 state_task->spawn(); | |
597 | |
598 return p; | |
599 } | |
600 | |
601 | |
602 CHARACTER* | |
603 Boss4Task(CHARACTER *p) | |
604 { | |
605 kyeenemyno = p; | |
606 | |
607 int task_num = p->task; | |
608 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
609 HTaskPtr state_task = tmanager->create_task(task_num); | |
610 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
611 obj->flag = false; | |
612 obj->length = 0; | |
613 | |
38 | 614 state_task->set_param(0, (memaddr)get_num()); |
615 | |
35 | 616 state_task->set_inData(0, p, sizeof(CHARACTER)); |
617 state_task->set_inData(1, &count, sizeof(int)); | |
618 | |
619 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
620 state_task->set_outData(1, &count, sizeof(int)); | |
621 state_task->set_outData(2, obj, 0); | |
25 | 622 |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
623 state_task->set_post(checkContainer, (void*)p, (void*)obj); |
25 | 624 state_task->set_cpu(SPE_ANY); |
625 state_task->spawn(); | |
626 | |
627 return p; | |
628 } | |
629 | |
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
630 |
25 | 631 CHARACTER* |
38 | 632 Boss5Task(CHARACTER *p) |
633 { | |
634 int task_num = p->task; | |
635 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
636 HTaskPtr state_task = tmanager->create_task(task_num); | |
637 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
638 obj->flag = false; | |
639 obj->length = 0; | |
640 | |
641 state_task->set_param(0, (memaddr)get_num()); | |
642 | |
643 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
644 state_task->set_inData(1, &jiki, sizeof(player)); | |
645 | |
646 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
647 state_task->set_outData(1, obj, 0); | |
648 | |
649 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
650 state_task->set_cpu(SPE_ANY); | |
651 state_task->spawn(); | |
652 | |
653 return p; | |
654 } | |
655 | |
656 | |
657 CHARACTER* | |
19 | 658 noaction(CHARACTER *p) |
659 { | |
660 return p; | |
661 } | |
662 | |
33 | 663 |
26 | 664 CHARACTER* |
19 | 665 delete_chara(CHARACTER *p) |
666 { | |
667 | |
668 CHARACTER *parent = p; | |
669 p->f = FALSE; | |
670 p->state = noaction; | |
671 p->collision = noaction; | |
672 return parent; | |
10 | 673 } |
18 | 674 |
33 | 675 |
26 | 676 CHARACTER* |
677 chara_state0(CHARACTER *p) | |
18 | 678 { |
21 | 679 p->task = STATE0; |
19 | 680 return SimpleStateTask(p); |
18 | 681 } |
682 | |
33 | 683 |
26 | 684 CHARACTER* |
685 chara_state1(CHARACTER *p) | |
18 | 686 { |
21 | 687 p->task = STATE1; |
19 | 688 return SimpleStateTask(p); |
18 | 689 } |
690 | |
33 | 691 |
26 | 692 CHARACTER* |
693 chara_state2(CHARACTER *p) | |
18 | 694 { |
21 | 695 p->task = STATE2; |
19 | 696 return SimpleStateTask(p); |
18 | 697 } |
698 | |
33 | 699 |
26 | 700 CHARACTER* |
701 chara_state3(CHARACTER *p) | |
18 | 702 { |
25 | 703 p->task = STATE3; |
33 | 704 return sendContainerTask(p); |
18 | 705 } |
706 | |
33 | 707 |
26 | 708 CHARACTER* |
709 chara_state4(CHARACTER *p) | |
18 | 710 { |
28 | 711 p->task = STATE4; |
19 | 712 return withJikiTask(p); |
18 | 713 } |
714 | |
33 | 715 |
26 | 716 CHARACTER* |
717 chara_state5(CHARACTER *p) | |
18 | 718 { |
21 | 719 p->task = STATE5; |
19 | 720 return withJikiTask(p); |
18 | 721 } |
722 | |
33 | 723 |
26 | 724 CHARACTER* |
725 chara_state6(CHARACTER *p) | |
18 | 726 { |
21 | 727 p->task = STATE6; |
19 | 728 return withJikiTask(p); |
18 | 729 } |
730 | |
33 | 731 |
26 | 732 CHARACTER* |
733 chara_state7(CHARACTER *p) | |
18 | 734 { |
26 | 735 p->task = STATE7; |
33 | 736 return sendContainerTask(p); |
18 | 737 } |
738 | |
739 | |
33 | 740 // state1 boss patern |
741 CHARACTER* | |
742 chara_state8(CHARACTER *p) | |
18 | 743 { |
33 | 744 tekino0 = p; |
745 kyeenemyno = p; | |
746 | |
747 p->task = STATE8; | |
34 | 748 return Boss1Task1(p); |
33 | 749 } |
750 | |
751 | |
752 CHARACTER* | |
753 chara_state9(CHARACTER *p) | |
754 { | |
755 p->task = STATE9; | |
34 | 756 return Boss1Task2(p); |
18 | 757 } |
758 | |
759 | |
33 | 760 CHARACTER* |
761 chara_state10(CHARACTER *p) | |
18 | 762 { |
33 | 763 p->task =STATE10; |
34 | 764 return Boss1Task3(p); |
18 | 765 } |
766 | |
33 | 767 |
768 CHARACTER* | |
769 chara_state11(CHARACTER *p) | |
18 | 770 { |
33 | 771 p->task = STATE11; |
34 | 772 return Boss1Task4(p); |
18 | 773 } |
774 | |
775 | |
33 | 776 CHARACTER* |
777 chara_state12(CHARACTER *p) | |
18 | 778 { |
33 | 779 p->task = STATE12; |
34 | 780 return Boss1Task5(p); |
33 | 781 } |
782 | |
18 | 783 |
33 | 784 CHARACTER* |
785 chara_state13(CHARACTER *p) | |
786 { | |
787 p->task = STATE13; | |
34 | 788 return Boss1Task6(p); |
18 | 789 } |
33 | 790 |
18 | 791 |
33 | 792 CHARACTER* |
793 chara_state20(CHARACTER *p) | |
18 | 794 { |
21 | 795 p->task = STATE20; |
19 | 796 return SimpleStateTask(p); |
18 | 797 } |
798 | |
33 | 799 |
800 CHARACTER* | |
801 chara_state21(CHARACTER *p) | |
18 | 802 { |
21 | 803 p->task = STATE21; |
19 | 804 return SimpleStateTask(p); |
18 | 805 } |
806 //ここまでgetate boss | |
807 | |
808 | |
34 | 809 CHARACTER* |
810 chara_state22(CHARACTER *p) | |
18 | 811 { |
38 | 812 p->task = STATE22; |
813 return FixRandomTask(p); | |
18 | 814 } |
27 | 815 |
816 | |
34 | 817 CHARACTER* |
818 chara_state23(CHARACTER *p) | |
18 | 819 { |
34 | 820 p->task = STATE23; |
821 return AsteroidTask(p); | |
18 | 822 } |
823 | |
33 | 824 |
34 | 825 CHARACTER* |
826 chara_state24(CHARACTER *p) | |
18 | 827 { |
34 | 828 kyeenemyno = p; |
829 tekino0 = 0; | |
830 enemy_part1 = p->next; | |
831 enemy_part2 = enemy_part1->next; | |
832 enemy_part3 = enemy_part2->next; | |
833 enemy_part4 = enemy_part3->next; | |
834 enemy_part5 = enemy_part4->next; | |
835 rinkx = 0; | |
836 rinky = 0; | |
837 rinkf1 = 0; | |
838 rinkf2 = 0; | |
839 p->task = STATE25; | |
18 | 840 |
34 | 841 int num = GetStateNum(p->task); |
842 p->state = state_list[num]; | |
843 return p; | |
18 | 844 } |
845 | |
34 | 846 CHARACTER* |
847 chara_state25(CHARACTER *p) | |
18 | 848 { |
34 | 849 p->task = STATE25; |
850 return Boss2Task1(p); | |
18 | 851 } |
852 | |
34 | 853 CHARACTER* |
854 chara_state26(CHARACTER *p) | |
18 | 855 { |
34 | 856 p->task = STATE26; |
857 return Boss2Task1(p); | |
18 | 858 } |
34 | 859 |
860 CHARACTER* | |
861 chara_state27(CHARACTER *p) //rocket punch | |
18 | 862 { |
34 | 863 p->task = STATE27; |
864 return Boss2Task1(p); | |
865 } | |
866 CHARACTER* | |
867 chara_state28(CHARACTER *p) | |
868 { | |
869 p->task = STATE28; | |
870 return Boss2Task1(p); | |
18 | 871 } |
872 | |
873 | |
34 | 874 CHARACTER* |
875 chara_state29(CHARACTER *p) | |
18 | 876 { |
34 | 877 p->task = STATE29; |
878 return sendContainerTask(p); | |
18 | 879 } |
34 | 880 |
18 | 881 |
34 | 882 CHARACTER* |
883 chara_state30(CHARACTER *p) | |
18 | 884 { |
21 | 885 p->task = STATE30; |
19 | 886 return SimpleStateTask(p); |
18 | 887 } |
888 | |
34 | 889 |
890 CHARACTER* | |
891 chara_state31(CHARACTER *p) //right hand | |
18 | 892 { |
34 | 893 p->task = STATE31; |
35 | 894 return Boss2Task2(p, 0, 0); |
18 | 895 } |
896 | |
897 | |
34 | 898 CHARACTER* |
899 chara_state32(CHARACTER *p) //left hand | |
18 | 900 { |
34 | 901 p->task = STATE32; |
35 | 902 return Boss2Task2(p, 14, 20); |
18 | 903 } |
904 | |
905 | |
35 | 906 |
907 CHARACTER* | |
908 chara_state33(CHARACTER *p) // right shoulder | |
18 | 909 { |
35 | 910 p->task = STATE33; |
911 return Boss2Task2(p, 11, 19); | |
912 } | |
913 | |
914 | |
915 CHARACTER* | |
916 chara_state34(CHARACTER *p) //left shoulder | |
917 { | |
918 p->task = STATE34; | |
919 return Boss2Task2(p, 12, 21); | |
18 | 920 } |
921 | |
922 | |
35 | 923 CHARACTER* |
924 chara_state35(CHARACTER *p) // bust | |
18 | 925 { |
35 | 926 p->task = STATE35; |
927 return Boss2Task2(p, 15, 16); | |
18 | 928 } |
929 | |
930 | |
35 | 931 |
932 CHARACTER* | |
933 chara_state40(CHARACTER *p) //arm vulkan | |
18 | 934 { |
35 | 935 p->task = STATE40; |
936 return Boss2Task2(p, 0, 0); | |
18 | 937 } |
938 | |
939 | |
35 | 940 CHARACTER* |
941 chara_state41(CHARACTER *p) //left arm up arm vulkan | |
18 | 942 { |
35 | 943 p->task = STATE41; |
944 return Boss2Task2(p, 0, 0); | |
18 | 945 } |
946 | |
947 | |
38 | 948 CHARACTER* |
949 chara_state400(CHARACTER *p) | |
18 | 950 { |
34 | 951 p->task = STATE400; |
19 | 952 return SimpleStateTask(p); |
18 | 953 } |
954 | |
955 | |
34 | 956 CHARACTER* |
957 chara_state401(CHARACTER *p) | |
18 | 958 { |
34 | 959 p->task = STATE401; |
960 return JikiContainerTask(p); | |
18 | 961 } |
962 | |
963 | |
34 | 964 CHARACTER* |
965 chara_state402(CHARACTER *p) | |
18 | 966 { |
34 | 967 p->task = STATE402; |
968 return JikiContainerTask(p); | |
18 | 969 } |
970 | |
971 | |
35 | 972 CHARACTER* |
973 chara_state410(CHARACTER *p) | |
18 | 974 { |
35 | 975 kyeenemyno = p; |
976 p->task = STATE411; | |
977 | |
978 int num = GetStateNum(p->task); | |
979 p->state = state_list[num]; | |
980 return p; | |
18 | 981 } |
982 | |
983 | |
35 | 984 CHARACTER* |
985 chara_state411(CHARACTER *p) | |
18 | 986 { |
35 | 987 p->task = STATE411; |
988 return JikiContainerTask(p); | |
989 } | |
990 | |
991 | |
992 CHARACTER* | |
993 chara_state500(CHARACTER *p) | |
994 { | |
995 p->task = STATE500; | |
996 return Boss4Task(p); | |
18 | 997 } |
998 | |
999 | |
35 | 1000 CHARACTER* |
1001 chara_state501(CHARACTER *p) | |
18 | 1002 { |
35 | 1003 p->task = STATE501; |
1004 return sendContainerTask(p); | |
18 | 1005 } |
1006 | |
1007 | |
35 | 1008 CHARACTER* |
1009 chara_state600(CHARACTER *p) | |
18 | 1010 { |
1011 kyeenemyno = p; | |
35 | 1012 p->task = STATE600; |
1013 return sendContainerTask(p); | |
18 | 1014 } |
1015 | |
1016 | |
35 | 1017 CHARACTER* |
1018 chara_state601(CHARACTER *p) | |
18 | 1019 { |
35 | 1020 p->task = STATE601; |
38 | 1021 return Boss5Task(p); |
18 | 1022 } |
1023 | |
1024 | |
35 | 1025 CHARACTER* |
1026 chara_state602(CHARACTER *p) | |
18 | 1027 { |
35 | 1028 p->task = STATE602; |
38 | 1029 return Boss5Task(p); |
18 | 1030 } |