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