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