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