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