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