Mercurial > hg > Members > koba > t_dandy
annotate state_task.cc @ 64:07bc996c8e49
fix t_dandy on ps3.
| author | koba <koba@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Fri, 11 Feb 2011 18:20:30 +0900 |
| parents | e66cab264350 |
| children | f27a6af6514c |
| 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" |
| 57 | 21 #include "collision_task.h" |
| 52 | 22 |
| 10 | 23 |
| 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 |
| 57 | 35 HTaskPtr state_next; |
| 36 | |
| 19 | 37 //int tekino0; |
| 33 | 38 int rinkx = 0; |
| 39 int rinky = 0; | |
| 19 | 40 int rinkf1 = 0, rinkf2 = 0; |
| 41 CHARACTER *asteroiddt[200]; | |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
42 |
| 19 | 43 int enemyfaste = 0; |
| 44 int fastebos = 0; | |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
45 int asteroidi = 0; |
| 19 | 46 |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
47 static int cpu_counter = SPE_1; |
| 38 | 48 |
| 57 | 49 HTaskPtr |
| 50 create_next() | |
| 51 { | |
| 52 state_next = tmanager->create_task(Dummy); | |
| 53 | |
| 54 return state_next; | |
| 55 } | |
|
56
a80422eb44a9
bug fix.TODO:print delete message on videoNONE mode.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
54
diff
changeset
|
56 |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
57 static CPU_TYPE |
|
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
58 get_cpunum() |
| 38 | 59 { |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
60 cpu_counter += 1; |
| 57 | 61 if ((cpu_counter % SPE_5) == 1) { |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
62 cpu_counter = SPE_1; |
|
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
63 } |
|
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
64 |
|
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
65 return (CPU_TYPE)cpu_counter; |
| 38 | 66 } |
| 36 | 67 |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
68 static int |
|
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
69 power_of_two(int input) |
| 36 | 70 { |
| 71 int value = 1; | |
| 72 | |
| 73 while ( value < input ) { | |
| 74 value <<= 1; | |
| 75 } | |
| 76 return value; | |
| 77 } | |
| 78 | |
| 52 | 79 |
| 36 | 80 static void |
| 81 ReDefSprite(int number, float w, float h, int color) | |
| 82 { | |
| 83 SpriteTable *m = &sptable[number]; | |
| 84 m->w = w; | |
| 85 m->h = h; | |
| 86 m->color = (color & 32); | |
| 87 m->mx = w / 2; | |
| 88 m->my = h / 2; | |
| 89 m->tex_w = power_of_two(m->w); | |
| 90 m->tex_h = power_of_two(m->h); | |
| 91 } | |
| 92 | |
| 59 | 93 void |
| 94 printState(SchedTask *s, void *chara, void *arg) | |
| 95 { | |
| 96 CHARACTER *p = (CHARACTER*)chara; | |
| 64 | 97 printf("[ID]%d [COORD]x= %f y= %f vx= %f vy= %f\n", |
| 98 p->chara_id, p->x, p->y, p->vx, p->vy); | |
| 59 | 99 |
| 100 state_check(p); | |
| 101 } | |
| 36 | 102 |
| 19 | 103 void |
| 104 updateState(SchedTask *s, void *chara, void *arg) | |
| 105 { | |
| 106 CHARACTER *p = (CHARACTER*)chara; | |
| 107 | |
| 57 | 108 state_check(p); |
| 19 | 109 } |
| 110 | |
| 30 | 111 |
| 112 void | |
| 34 | 113 freeObject(SchedTask *s, void *chara, void *obj) |
| 114 { | |
| 115 free(obj); | |
| 116 | |
| 117 CHARACTER *p = (CHARACTER*)chara; | |
| 38 | 118 |
| 57 | 119 state_check(p); |
| 34 | 120 } |
| 121 | |
| 122 | |
| 123 void | |
| 30 | 124 checkContainer(SchedTask *s, void *chara, void *obj) |
| 125 { | |
| 126 CHARACTER *p = (CHARACTER*)chara; | |
| 127 ObjContainer *new_obj = (ObjContainerPtr)obj; | |
|
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
128 |
|
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
129 if (new_obj->flag == true) { |
|
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
130 int length = new_obj->length; |
|
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
131 |
| 33 | 132 for (int i=0; i < length; i++) { |
| 133 ObjDataPtr obj_data = &new_obj->data[i]; | |
| 134 int type = obj_data->type; | |
| 135 | |
| 136 switch (type) { | |
| 37 | 137 case Boms: |
| 138 Bom(obj_data->x, obj_data->y); | |
| 139 break; | |
| 33 | 140 case Tama: |
| 141 Puttama(obj_data->tama_type, obj_data->x, obj_data->y); | |
| 142 break; | |
| 143 case Enemy: { | |
| 144 int task_num = GetStateNum(obj_data->task); | |
| 145 Putenemy(obj_data->charano, obj_data->x, obj_data->y, | |
| 53 | 146 obj_data->vx, obj_data->vy, state_list[task_num].state); |
| 33 | 147 break; |
|
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
148 } |
| 33 | 149 case Def: |
| 36 | 150 ReDefSprite(obj_data->number, obj_data->w, obj_data->h, obj_data->color); |
| 33 | 151 break; |
| 152 case DefEx: | |
| 153 DefSpriteEx(obj_data->number, obj_data->middlex, obj_data->middley); | |
| 154 break; | |
| 155 case Put: | |
| 156 PutSprite(obj_data->zorder, obj_data->x, obj_data->y, obj_data->number); | |
| 157 break; | |
| 158 case PutEx: | |
| 159 PutSpriteEx(obj_data->number, obj_data->x, obj_data->y, | |
| 160 obj_data->scalex, obj_data->scaley, obj_data->angle); | |
| 161 break; | |
| 36 | 162 } |
|
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
163 } |
|
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
164 } |
| 57 | 165 |
| 166 state_check(p); | |
| 30 | 167 free(new_obj); |
| 168 } | |
| 169 | |
| 170 | |
| 19 | 171 CHARACTER* |
| 10 | 172 SimpleStateTask(CHARACTER *p) |
| 173 { | |
| 57 | 174 int task_num = p->state_task; |
| 19 | 175 HTaskPtr state_task = tmanager->create_task(task_num); |
| 33 | 176 |
| 30 | 177 state_task->set_inData(0, p, sizeof(CHARACTER)); |
| 33 | 178 |
| 30 | 179 state_task->set_outData(0, p, sizeof(CHARACTER)); |
| 33 | 180 |
| 19 | 181 state_task->set_post(updateState, (void*)p, NULL); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
182 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
183 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
184 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
185 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
186 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
187 #endif |
| 57 | 188 |
| 189 state_next->wait_for(state_task); | |
| 10 | 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* |
| 58 | 197 sendRandomTask(CHARACTER *p) |
| 38 | 198 { |
| 57 | 199 int task_num = p->state_task; |
| 38 | 200 HTaskPtr state_task = tmanager->create_task(task_num); |
| 64 | 201 |
| 202 uint32 rand1 = random(); | |
| 203 uint32 rand2 = random(); | |
| 204 uint32 rand3 = random(); | |
| 205 uint32 rand4 = random(); | |
| 38 | 206 |
| 64 | 207 state_task->set_param(0, (memaddr)rand1); |
| 208 state_task->set_param(1, (memaddr)rand2); | |
| 209 state_task->set_param(2, (memaddr)rand3); | |
| 210 state_task->set_param(3, (memaddr)rand4); | |
| 38 | 211 |
| 212 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 213 | |
| 214 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 215 | |
| 64 | 216 state_task->set_post(updateState, (void*)p, NULL); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
217 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
218 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
219 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
220 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
221 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
222 #endif |
| 57 | 223 |
| 224 state_next->wait_for(state_task); | |
| 38 | 225 state_task->spawn(); |
| 226 | |
| 227 return p; | |
| 228 } | |
| 229 | |
| 230 | |
| 231 CHARACTER* | |
| 19 | 232 withJikiTask(CHARACTER *p) |
| 233 { | |
| 57 | 234 int task_num = p->state_task; |
| 19 | 235 HTaskPtr state_task = tmanager->create_task(task_num); |
| 25 | 236 |
| 30 | 237 state_task->set_inData(0, p, sizeof(CHARACTER)); |
| 238 state_task->set_inData(1, &jiki, sizeof(player)); | |
| 33 | 239 |
| 30 | 240 state_task->set_outData(0, p, sizeof(CHARACTER)); |
| 33 | 241 |
| 19 | 242 state_task->set_post(updateState, (void*)p, NULL); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
243 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
244 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
245 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
246 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
247 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
248 #endif |
| 57 | 249 |
| 250 state_next->wait_for(state_task); | |
| 33 | 251 state_task->spawn(); |
| 19 | 252 |
| 33 | 253 return p; |
| 254 } | |
| 255 | |
| 256 | |
| 257 CHARACTER* | |
| 258 sendContainerTask(CHARACTER *p) | |
| 259 { | |
| 57 | 260 int task_num = p->state_task; |
| 33 | 261 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 262 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 263 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 264 obj->flag = false; | |
| 265 obj->length = 0; | |
| 266 | |
| 267 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 268 | |
| 269 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 270 state_task->set_outData(1, obj, 0); | |
| 271 | |
| 38 | 272 state_task->set_post(checkContainer, (void*)p, (void*)obj); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
273 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
274 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
275 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
276 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
277 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
278 #endif |
| 57 | 279 |
| 280 state_next->wait_for(state_task); | |
| 33 | 281 state_task->spawn(); |
| 282 | |
| 283 return p; | |
| 284 } | |
| 285 | |
| 286 | |
| 287 CHARACTER* | |
| 34 | 288 JikiContainerTask(CHARACTER *p) |
| 33 | 289 { |
| 57 | 290 int task_num = p->state_task; |
| 33 | 291 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 292 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 293 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 294 obj->flag = false; | |
| 295 obj->length = 0; | |
| 296 | |
| 34 | 297 state_task->set_inData(0, p, sizeof(CHARACTER)); |
| 298 state_task->set_inData(1, &jiki, sizeof(player)); | |
| 299 | |
| 300 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 301 state_task->set_outData(1, obj, 0); | |
| 302 | |
| 303 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
304 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
305 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
306 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
307 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
308 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
309 #endif |
| 57 | 310 |
| 311 state_next->wait_for(state_task); | |
| 34 | 312 state_task->spawn(); |
| 313 | |
| 314 return p; | |
| 315 } | |
| 316 | |
| 317 | |
| 318 CHARACTER* | |
| 319 AsteroidTask(CHARACTER *p) | |
| 320 { | |
| 321 asteroiddt[asteroidi] = p; | |
| 322 | |
| 323 int task_num = ASTEROID_TASK; | |
| 324 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 325 | |
| 326 state_task->set_param(0, (memaddr)asteroidi); | |
| 327 | |
| 328 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 329 | |
| 330 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 331 | |
| 332 int array_size = sizeof(CHARACTER)*asteroidi; | |
| 333 if (array_size > 0) { | |
| 334 CHARACTER *asteroid_array = (CHARACTER*)tmanager->allocate(array_size); | |
| 335 for (int i = 0; i < asteroidi; i++) { | |
| 336 asteroid_array[i] = *asteroiddt[i]; | |
| 337 } | |
| 338 state_task->set_inData(1, asteroid_array, array_size); | |
| 339 state_task->set_post(freeObject, (void*)p, (void*)asteroid_array); | |
| 340 } else { | |
| 341 state_task->set_post(updateState, (void*)p, NULL); | |
| 342 } | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
343 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
344 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
345 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
346 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
347 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
348 #endif |
| 57 | 349 |
| 350 state_next->wait_for(state_task); | |
| 34 | 351 state_task->spawn(); |
| 38 | 352 |
| 34 | 353 asteroidi++; |
| 354 return p; | |
| 355 } | |
| 356 | |
| 357 | |
| 358 CHARACTER* | |
| 359 Boss1Task1(CHARACTER *p) | |
| 360 { | |
| 57 | 361 int task_num = p->state_task; |
| 34 | 362 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 363 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 364 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 365 obj->flag = false; | |
| 366 obj->length = 0; | |
| 33 | 367 |
| 368 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 34 | 369 state_task->set_inData(1, &count, sizeof(int)); |
| 33 | 370 |
| 371 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 372 state_task->set_outData(1, &count, sizeof(int)); | |
| 373 state_task->set_outData(2, obj, 0); | |
| 374 | |
| 375 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
376 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
377 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
378 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
379 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
380 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
381 #endif |
| 57 | 382 |
| 383 state_next->wait_for(state_task); | |
| 33 | 384 state_task->spawn(); |
| 385 | |
| 386 return p; | |
| 387 } | |
| 388 | |
| 389 | |
| 390 CHARACTER* | |
| 34 | 391 Boss1Task2(CHARACTER *p) |
| 33 | 392 { |
| 57 | 393 int task_num = p->state_task; |
| 33 | 394 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 395 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 396 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 397 obj->flag = false; | |
| 398 obj->length = 0; | |
| 399 | |
| 400 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 34 | 401 state_task->set_inData(1, &count, sizeof(int)); |
| 33 | 402 |
| 403 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 404 state_task->set_outData(1, &count, sizeof(int)); | |
| 405 state_task->set_outData(2, &rinkx, sizeof(int)); | |
| 406 state_task->set_outData(3, &rinky, sizeof(int)); | |
| 407 state_task->set_outData(4, obj, 0); | |
| 408 | |
| 409 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
410 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
411 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
412 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
413 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
414 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
415 #endif |
| 57 | 416 |
| 417 state_next->wait_for(state_task); | |
| 19 | 418 state_task->spawn(); |
| 419 | |
| 420 return p; | |
| 421 } | |
| 422 | |
|
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
423 |
| 19 | 424 CHARACTER* |
| 34 | 425 Boss1Task3(CHARACTER *p) |
| 33 | 426 { |
| 57 | 427 int task_num = p->state_task; |
| 33 | 428 HTaskPtr state_task = tmanager->create_task(task_num); |
| 429 | |
| 430 state_task->set_param(0, (memaddr)rinkx); | |
| 431 state_task->set_param(1, (memaddr)rinky); | |
| 432 | |
| 433 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 434 | |
| 435 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 436 state_task->set_outData(1, &rinkf1, sizeof(int)); | |
| 437 | |
| 438 state_task->set_post(updateState, (void*)p, NULL); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
439 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
440 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
441 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
442 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
443 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
444 #endif |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
445 |
| 57 | 446 |
| 447 state_next->wait_for(state_task); | |
| 33 | 448 state_task->spawn(); |
| 449 | |
| 450 return p; | |
| 451 } | |
| 452 | |
| 453 | |
| 454 CHARACTER* | |
| 34 | 455 Boss1Task4(CHARACTER *p) |
| 33 | 456 { |
| 57 | 457 int task_num = p->state_task; |
| 33 | 458 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 459 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 460 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 461 obj->flag = false; | |
| 462 obj->length = 0; | |
| 463 | |
| 464 state_task->set_param(0, (memaddr)rinkf1); | |
| 465 state_task->set_param(1, (memaddr)count); | |
| 466 | |
| 467 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 468 | |
| 469 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 470 state_task->set_outData(1, &count, sizeof(int)); | |
| 471 state_task->set_outData(2, obj, 0); | |
| 472 | |
| 473 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
474 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
475 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
476 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
477 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
478 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
479 #endif |
| 57 | 480 |
| 481 state_next->wait_for(state_task); | |
| 33 | 482 state_task->spawn(); |
| 483 | |
| 484 return p; | |
| 485 } | |
| 486 | |
| 487 | |
| 488 CHARACTER* | |
| 34 | 489 Boss1Task5(CHARACTER *p) |
| 25 | 490 { |
| 57 | 491 int task_num = p->state_task; |
|
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
492 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 25 | 493 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
|
494 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); |
| 33 | 495 obj->flag = false; |
|
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
496 obj->length = 0; |
| 25 | 497 |
| 33 | 498 state_task->set_param(0, (memaddr)fastebos); |
| 499 state_task->set_param(1, (memaddr)count); | |
| 500 state_task->set_param(2, (memaddr)rinkx); | |
| 501 state_task->set_param(3, (memaddr)rinky); | |
| 502 | |
| 503 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 504 state_task->set_inData(1, &jiki, sizeof(player)); | |
| 505 | |
| 506 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 507 state_task->set_outData(1, &count, sizeof(int)); | |
| 508 state_task->set_outData(2, &fastebos, sizeof(int)); | |
| 509 state_task->set_outData(3, &rinkx, sizeof(int)); | |
| 510 state_task->set_outData(4, &rinky, sizeof(int)); | |
| 511 state_task->set_outData(5, &rinkf2, sizeof(int)); | |
| 512 state_task->set_outData(6, obj, 0); | |
| 513 | |
| 514 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
515 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
516 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
517 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
518 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
519 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
520 #endif |
| 57 | 521 |
| 522 state_next->wait_for(state_task); | |
| 33 | 523 state_task->spawn(); |
| 524 | |
| 525 return p; | |
| 526 } | |
| 527 | |
| 528 | |
| 529 CHARACTER* | |
| 34 | 530 Boss1Task6(CHARACTER *p) |
| 33 | 531 { |
| 57 | 532 int task_num = p->state_task; |
| 33 | 533 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 534 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 535 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 536 obj->flag = false; | |
| 537 obj->length = 0; | |
| 538 | |
| 539 state_task->set_param(0, (memaddr)rinkx); | |
| 540 state_task->set_param(1, (memaddr)rinky); | |
| 34 | 541 state_task->set_param(2, (memaddr)filpcount); |
| 542 state_task->set_param(3, (memaddr)tekino0->f); | |
| 543 state_task->set_param(4, (memaddr)count); | |
| 33 | 544 |
| 30 | 545 state_task->set_inData(0, p, sizeof(CHARACTER)); |
| 37 | 546 state_task->set_inData(1, &rinkf2, sizeof(int)); |
| 33 | 547 |
| 30 | 548 state_task->set_outData(0, p, sizeof(CHARACTER)); |
| 33 | 549 state_task->set_outData(1, &count, sizeof(int)); |
| 37 | 550 state_task->set_outData(2, obj, 0); |
| 34 | 551 |
| 552 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
553 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
554 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
555 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
556 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
557 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
558 #endif |
| 57 | 559 |
| 560 state_next->wait_for(state_task); | |
| 34 | 561 state_task->spawn(); |
| 562 | |
| 563 return p; | |
| 564 } | |
| 565 | |
| 566 | |
| 567 CHARACTER* | |
| 568 Boss2Task1(CHARACTER *p) | |
| 569 { | |
| 57 | 570 int task_num = p->state_task; |
| 34 | 571 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 572 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 573 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 574 obj->flag = false; | |
| 575 obj->length = 0; | |
| 576 | |
| 577 state_task->set_param(0, (memaddr)enemy_part1->f); | |
| 578 state_task->set_param(1, (memaddr)enemy_part5->f); | |
| 58 | 579 state_task->set_param(2, (memaddr)random()); |
| 580 | |
| 581 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 582 state_task->set_inData(1, &count, sizeof(int)); | |
| 583 | |
| 584 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 585 state_task->set_outData(1, &count, sizeof(int)); | |
| 586 state_task->set_outData(2, &rinkx, sizeof(int)); | |
| 587 state_task->set_outData(3, &rinkf1, sizeof(int)); | |
| 588 state_task->set_outData(4, obj, 0); | |
| 589 | |
| 590 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
591 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
592 #ifndef PPE_ONLY |
| 58 | 593 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
594 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
595 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
596 #endif |
| 58 | 597 |
| 598 state_next->wait_for(state_task); | |
| 599 state_task->spawn(); | |
| 600 | |
| 601 return p; | |
| 602 } | |
| 603 | |
| 604 | |
| 605 CHARACTER* | |
| 606 Boss2Task2(CHARACTER *p) | |
| 607 { | |
| 608 int task_num = p->state_task; | |
| 609 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
| 610 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 611 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 612 obj->flag = false; | |
| 613 obj->length = 0; | |
| 34 | 614 |
| 615 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 616 state_task->set_inData(1, &count, sizeof(int)); | |
| 617 state_task->set_inData(2, &rinkx, sizeof(int)); | |
| 618 state_task->set_inData(3, &rinkf1, sizeof(int)); | |
| 619 | |
| 620 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 621 state_task->set_outData(1, &count, sizeof(int)); | |
| 622 state_task->set_outData(2, &rinkx, sizeof(int)); | |
| 623 state_task->set_outData(3, &rinkf1, sizeof(int)); | |
| 624 state_task->set_outData(4, obj, 0); | |
| 625 | |
| 626 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
627 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
628 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
629 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
630 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
631 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
632 #endif |
| 57 | 633 |
| 634 state_next->wait_for(state_task); | |
| 34 | 635 state_task->spawn(); |
| 636 | |
| 637 return p; | |
| 638 } | |
| 639 | |
| 58 | 640 static int myrand = 1; |
| 34 | 641 |
| 642 CHARACTER* | |
| 58 | 643 Boss2Task3(CHARACTER *p) |
| 644 { | |
| 645 int task_num = p->state_task; | |
| 646 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
| 647 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 648 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 649 obj->flag = false; | |
| 650 obj->length = 0; | |
| 651 | |
| 652 state_task->set_param(0, (memaddr)myrand); | |
| 653 | |
| 654 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 655 state_task->set_inData(1, &count, sizeof(int)); | |
| 656 | |
| 657 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 658 state_task->set_outData(1, &count, sizeof(int)); | |
| 659 state_task->set_outData(2, obj, 0); | |
| 660 | |
| 661 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
662 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
663 #ifndef PPE_ONLY |
| 58 | 664 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
665 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
666 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
667 #endif |
| 58 | 668 |
| 669 state_next->wait_for(state_task); | |
| 670 state_task->spawn(); | |
| 671 | |
| 672 return p; | |
| 673 } | |
| 674 | |
| 675 | |
| 676 CHARACTER* | |
| 677 Boss2Task4(CHARACTER *p, int num1, int num2) | |
| 34 | 678 { |
| 57 | 679 int task_num = p->state_task; |
| 34 | 680 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 681 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 682 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 683 obj->flag = false; | |
| 684 obj->length = 0; | |
| 685 | |
| 35 | 686 state_task->set_param(0, (memaddr)enemy_part1->f); |
| 687 state_task->set_param(1, (memaddr)enemy_part2->f); | |
| 688 state_task->set_param(2, (memaddr)enemy_part3->f); | |
| 689 state_task->set_param(3, (memaddr)enemy_part4->f); | |
| 690 state_task->set_param(4, (memaddr)enemystate[num1].charano); | |
| 691 state_task->set_param(5, (memaddr)enemystate[num2].charano); | |
| 34 | 692 |
| 693 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 694 state_task->set_inData(1, kyeenemyno, sizeof(CHARACTER)); | |
| 695 state_task->set_inData(2, &count, sizeof(int)); | |
| 696 state_task->set_inData(3, &rinkf1, sizeof(int)); | |
| 697 | |
| 698 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 699 state_task->set_outData(1, &count, sizeof(int)); | |
| 35 | 700 state_task->set_outData(2, obj, 0); |
| 701 | |
| 702 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
703 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
704 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
705 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
706 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
707 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
708 #endif |
| 57 | 709 |
| 710 state_next->wait_for(state_task); | |
| 35 | 711 state_task->spawn(); |
| 712 | |
| 713 return p; | |
| 714 } | |
| 715 | |
| 716 | |
| 717 CHARACTER* | |
| 58 | 718 Boss2Task5(CHARACTER *p, int num1, int num2) |
| 719 { | |
| 720 int task_num = p->state_task; | |
| 721 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
| 722 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 723 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 724 obj->flag = false; | |
| 725 obj->length = 0; | |
| 726 | |
| 727 state_task->set_param(0, (memaddr)enemy_part1->f); | |
| 728 state_task->set_param(1, (memaddr)enemy_part2->f); | |
| 729 state_task->set_param(2, (memaddr)enemy_part3->f); | |
| 730 state_task->set_param(3, (memaddr)enemy_part4->f); | |
| 731 state_task->set_param(4, (memaddr)enemystate[num1].charano); | |
| 732 state_task->set_param(5, (memaddr)enemystate[num2].charano); | |
| 733 | |
| 734 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 735 state_task->set_inData(1, kyeenemyno, sizeof(CHARACTER)); | |
| 736 state_task->set_inData(3, &rinkf2, sizeof(int)); | |
| 737 | |
| 738 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 739 state_task->set_outData(1, obj, 0); | |
| 740 | |
| 741 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
742 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
743 #ifndef PPE_ONLY |
| 58 | 744 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
745 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
746 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
747 #endif |
| 58 | 748 |
| 749 state_next->wait_for(state_task); | |
| 750 state_task->spawn(); | |
| 751 | |
| 752 return p; | |
| 753 } | |
| 754 | |
| 755 | |
| 756 CHARACTER* | |
| 35 | 757 Boss4Task(CHARACTER *p) |
| 758 { | |
| 759 kyeenemyno = p; | |
| 760 | |
| 57 | 761 int task_num = p->state_task; |
| 35 | 762 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 763 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 764 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 765 obj->flag = false; | |
| 766 obj->length = 0; | |
| 767 | |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
768 state_task->set_param(0, (memaddr)myrand); |
| 38 | 769 |
| 35 | 770 state_task->set_inData(0, p, sizeof(CHARACTER)); |
| 771 state_task->set_inData(1, &count, sizeof(int)); | |
| 772 | |
| 773 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 774 state_task->set_outData(1, &count, sizeof(int)); | |
| 775 state_task->set_outData(2, obj, 0); | |
| 25 | 776 |
|
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
777 state_task->set_post(checkContainer, (void*)p, (void*)obj); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
778 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
779 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
780 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
781 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
782 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
783 #endif |
| 57 | 784 |
| 785 state_next->wait_for(state_task); | |
| 25 | 786 state_task->spawn(); |
| 787 | |
| 788 return p; | |
| 789 } | |
| 790 | |
|
31
ccb8d9956a1e
add multi container function.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
30
diff
changeset
|
791 |
| 25 | 792 CHARACTER* |
| 58 | 793 Boss5Task1(CHARACTER *p) |
| 38 | 794 { |
| 57 | 795 int task_num = p->state_task; |
| 38 | 796 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; |
| 797 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 798 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 799 obj->flag = false; | |
| 800 obj->length = 0; | |
| 801 | |
| 58 | 802 state_task->set_param(0, (memaddr)random()); |
| 803 state_task->set_param(1, (memaddr)random()); | |
| 804 | |
| 805 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 806 state_task->set_inData(1, &jiki, sizeof(player)); | |
| 807 | |
| 808 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 809 state_task->set_outData(1, obj, 0); | |
| 810 | |
| 811 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
812 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
813 #ifndef PPE_ONLY |
| 58 | 814 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
815 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
816 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
817 #endif |
| 58 | 818 |
| 819 state_next->wait_for(state_task); | |
| 820 state_task->spawn(); | |
| 821 | |
| 822 return p; | |
| 823 } | |
| 824 | |
| 825 | |
| 826 CHARACTER* | |
| 827 Boss5Task2(CHARACTER *p) | |
| 828 { | |
| 829 int task_num = p->state_task; | |
| 830 int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH; | |
| 831 HTaskPtr state_task = tmanager->create_task(task_num); | |
| 832 ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size); | |
| 833 obj->flag = false; | |
| 834 obj->length = 0; | |
| 835 | |
| 836 state_task->set_param(0, (memaddr)random()); | |
| 837 state_task->set_param(1, (memaddr)random()); | |
| 838 state_task->set_param(2, (memaddr)random()); | |
| 839 state_task->set_param(3, (memaddr)random()); | |
| 38 | 840 |
| 841 state_task->set_inData(0, p, sizeof(CHARACTER)); | |
| 842 state_task->set_inData(1, &jiki, sizeof(player)); | |
| 843 | |
| 844 state_task->set_outData(0, p, sizeof(CHARACTER)); | |
| 845 state_task->set_outData(1, obj, 0); | |
| 846 | |
| 847 state_task->set_post(checkContainer, (void*)p, (void*)obj); | |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
848 |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
849 #ifndef PPE_ONLY |
|
54
3acdeb3dc3e8
collision use global_alloc (not work)
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
53
diff
changeset
|
850 state_task->set_cpu(get_cpunum()); |
|
61
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
851 #else |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
852 state_task->set_cpu(CPU_PPE); |
|
e66cab264350
RenderingEngine Task is worked on spe, task_dandy Task is worked on ppe
yutaka@localhost.localdomain
parents:
59
diff
changeset
|
853 #endif |
| 57 | 854 |
| 855 state_next->wait_for(state_task); | |
| 38 | 856 state_task->spawn(); |
| 857 | |
| 858 return p; | |
| 859 } | |
| 860 | |
| 861 | |
| 862 CHARACTER* | |
| 19 | 863 noaction(CHARACTER *p) |
| 864 { | |
| 865 return p; | |
| 866 } | |
| 867 | |
| 33 | 868 |
| 26 | 869 CHARACTER* |
| 19 | 870 delete_chara(CHARACTER *p) |
| 871 { | |
| 53 | 872 CHARACTER *parent = p; |
| 873 p->f = FALSE; | |
| 874 p->state = noaction; | |
| 875 p->collision = noaction; | |
| 876 return parent; | |
| 10 | 877 } |
| 18 | 878 |
| 33 | 879 |
| 26 | 880 CHARACTER* |
| 881 chara_state0(CHARACTER *p) | |
| 18 | 882 { |
| 57 | 883 p->state_task = STATE0; |
| 19 | 884 return SimpleStateTask(p); |
| 18 | 885 } |
| 886 | |
| 33 | 887 |
| 26 | 888 CHARACTER* |
| 889 chara_state1(CHARACTER *p) | |
| 18 | 890 { |
| 57 | 891 p->state_task = STATE1; |
| 19 | 892 return SimpleStateTask(p); |
| 18 | 893 } |
| 894 | |
| 33 | 895 |
| 26 | 896 CHARACTER* |
| 897 chara_state2(CHARACTER *p) | |
| 18 | 898 { |
| 57 | 899 p->state_task = STATE2; |
| 19 | 900 return SimpleStateTask(p); |
| 18 | 901 } |
| 902 | |
| 33 | 903 |
| 26 | 904 CHARACTER* |
| 905 chara_state3(CHARACTER *p) | |
| 18 | 906 { |
| 57 | 907 p->state_task = STATE3; |
| 33 | 908 return sendContainerTask(p); |
| 18 | 909 } |
| 910 | |
| 33 | 911 |
| 26 | 912 CHARACTER* |
| 913 chara_state4(CHARACTER *p) | |
| 18 | 914 { |
| 57 | 915 p->state_task = STATE4; |
| 19 | 916 return withJikiTask(p); |
| 18 | 917 } |
| 918 | |
| 33 | 919 |
| 26 | 920 CHARACTER* |
| 921 chara_state5(CHARACTER *p) | |
| 18 | 922 { |
| 57 | 923 p->state_task = STATE5; |
| 19 | 924 return withJikiTask(p); |
| 18 | 925 } |
| 926 | |
| 33 | 927 |
| 26 | 928 CHARACTER* |
| 929 chara_state6(CHARACTER *p) | |
| 18 | 930 { |
| 57 | 931 p->state_task = STATE6; |
| 19 | 932 return withJikiTask(p); |
| 18 | 933 } |
| 934 | |
| 33 | 935 |
| 26 | 936 CHARACTER* |
| 937 chara_state7(CHARACTER *p) | |
| 18 | 938 { |
| 57 | 939 p->state_task = STATE7; |
| 33 | 940 return sendContainerTask(p); |
| 18 | 941 } |
| 942 | |
| 943 | |
| 33 | 944 // state1 boss patern |
| 945 CHARACTER* | |
| 946 chara_state8(CHARACTER *p) | |
| 18 | 947 { |
| 33 | 948 tekino0 = p; |
| 949 kyeenemyno = p; | |
| 950 | |
| 57 | 951 p->state_task = STATE8; |
| 34 | 952 return Boss1Task1(p); |
| 33 | 953 } |
| 954 | |
| 955 | |
| 956 CHARACTER* | |
| 957 chara_state9(CHARACTER *p) | |
| 958 { | |
| 57 | 959 p->state_task = STATE9; |
| 34 | 960 return Boss1Task2(p); |
| 18 | 961 } |
| 962 | |
| 963 | |
| 33 | 964 CHARACTER* |
| 965 chara_state10(CHARACTER *p) | |
| 18 | 966 { |
| 57 | 967 p->state_task =STATE10; |
| 34 | 968 return Boss1Task3(p); |
| 18 | 969 } |
| 970 | |
| 33 | 971 |
| 972 CHARACTER* | |
| 973 chara_state11(CHARACTER *p) | |
| 18 | 974 { |
| 57 | 975 p->state_task = STATE11; |
| 34 | 976 return Boss1Task4(p); |
| 18 | 977 } |
| 978 | |
| 979 | |
| 33 | 980 CHARACTER* |
| 981 chara_state12(CHARACTER *p) | |
| 18 | 982 { |
| 57 | 983 p->state_task = STATE12; |
| 34 | 984 return Boss1Task5(p); |
| 33 | 985 } |
| 986 | |
| 18 | 987 |
| 33 | 988 CHARACTER* |
| 989 chara_state13(CHARACTER *p) | |
| 990 { | |
| 57 | 991 p->state_task = STATE13; |
| 34 | 992 return Boss1Task6(p); |
| 18 | 993 } |
| 33 | 994 |
| 18 | 995 |
| 33 | 996 CHARACTER* |
| 997 chara_state20(CHARACTER *p) | |
| 18 | 998 { |
| 57 | 999 p->state_task = STATE20; |
| 19 | 1000 return SimpleStateTask(p); |
| 18 | 1001 } |
| 1002 | |
| 33 | 1003 |
| 1004 CHARACTER* | |
| 1005 chara_state21(CHARACTER *p) | |
| 18 | 1006 { |
| 57 | 1007 p->state_task = STATE21; |
| 19 | 1008 return SimpleStateTask(p); |
| 18 | 1009 } |
| 1010 //ここまでgetate boss | |
| 1011 | |
| 1012 | |
| 34 | 1013 CHARACTER* |
| 1014 chara_state22(CHARACTER *p) | |
| 18 | 1015 { |
| 57 | 1016 p->state_task = STATE22; |
| 58 | 1017 return sendRandomTask(p); |
| 18 | 1018 } |
| 27 | 1019 |
| 1020 | |
| 34 | 1021 CHARACTER* |
| 1022 chara_state23(CHARACTER *p) | |
| 18 | 1023 { |
| 57 | 1024 p->state_task = STATE23; |
| 34 | 1025 return AsteroidTask(p); |
| 18 | 1026 } |
| 1027 | |
| 33 | 1028 |
| 34 | 1029 CHARACTER* |
| 1030 chara_state24(CHARACTER *p) | |
| 18 | 1031 { |
| 34 | 1032 kyeenemyno = p; |
| 1033 tekino0 = 0; | |
| 1034 enemy_part1 = p->next; | |
| 1035 enemy_part2 = enemy_part1->next; | |
| 1036 enemy_part3 = enemy_part2->next; | |
| 1037 enemy_part4 = enemy_part3->next; | |
| 1038 enemy_part5 = enemy_part4->next; | |
| 1039 rinkx = 0; | |
| 1040 rinky = 0; | |
| 1041 rinkf1 = 0; | |
| 1042 rinkf2 = 0; | |
| 57 | 1043 p->state_task = STATE25; |
| 18 | 1044 |
| 57 | 1045 state_check(p); |
| 34 | 1046 return p; |
| 18 | 1047 } |
| 1048 | |
| 34 | 1049 CHARACTER* |
| 1050 chara_state25(CHARACTER *p) | |
| 18 | 1051 { |
| 57 | 1052 p->state_task = STATE25; |
| 34 | 1053 return Boss2Task1(p); |
| 18 | 1054 } |
| 1055 | |
| 34 | 1056 CHARACTER* |
| 1057 chara_state26(CHARACTER *p) | |
| 18 | 1058 { |
| 57 | 1059 p->state_task = STATE26; |
| 58 | 1060 return Boss2Task2(p); |
| 18 | 1061 } |
| 34 | 1062 |
| 1063 CHARACTER* | |
| 1064 chara_state27(CHARACTER *p) //rocket punch | |
| 18 | 1065 { |
| 57 | 1066 p->state_task = STATE27; |
| 58 | 1067 return Boss2Task2(p); |
| 34 | 1068 } |
| 1069 CHARACTER* | |
| 1070 chara_state28(CHARACTER *p) | |
| 1071 { | |
| 57 | 1072 p->state_task = STATE28; |
| 58 | 1073 //if many rand |
| 1074 return Boss2Task3(p); | |
| 18 | 1075 } |
| 1076 | |
| 1077 | |
| 34 | 1078 CHARACTER* |
| 1079 chara_state29(CHARACTER *p) | |
| 18 | 1080 { |
| 57 | 1081 p->state_task = STATE29; |
| 34 | 1082 return sendContainerTask(p); |
| 18 | 1083 } |
| 34 | 1084 |
| 18 | 1085 |
| 34 | 1086 CHARACTER* |
| 1087 chara_state30(CHARACTER *p) | |
| 18 | 1088 { |
| 57 | 1089 p->state_task = STATE30; |
| 19 | 1090 return SimpleStateTask(p); |
| 18 | 1091 } |
| 1092 | |
| 34 | 1093 |
| 1094 CHARACTER* | |
| 1095 chara_state31(CHARACTER *p) //right hand | |
| 18 | 1096 { |
| 57 | 1097 p->state_task = STATE31; |
| 58 | 1098 return Boss2Task4(p, 0, 0); |
| 18 | 1099 } |
| 1100 | |
| 1101 | |
| 34 | 1102 CHARACTER* |
| 1103 chara_state32(CHARACTER *p) //left hand | |
| 18 | 1104 { |
| 57 | 1105 p->state_task = STATE32; |
| 58 | 1106 return Boss2Task4(p, 14, 20); |
| 18 | 1107 } |
| 1108 | |
| 1109 | |
| 35 | 1110 |
| 1111 CHARACTER* | |
| 1112 chara_state33(CHARACTER *p) // right shoulder | |
| 18 | 1113 { |
| 57 | 1114 p->state_task = STATE33; |
| 58 | 1115 return Boss2Task4(p, 11, 19); |
| 35 | 1116 } |
| 1117 | |
| 1118 | |
| 1119 CHARACTER* | |
| 1120 chara_state34(CHARACTER *p) //left shoulder | |
| 1121 { | |
| 57 | 1122 p->state_task = STATE34; |
| 58 | 1123 return Boss2Task4(p, 12, 21); |
| 18 | 1124 } |
| 1125 | |
| 1126 | |
| 35 | 1127 CHARACTER* |
| 1128 chara_state35(CHARACTER *p) // bust | |
| 18 | 1129 { |
| 57 | 1130 p->state_task = STATE35; |
| 58 | 1131 return Boss2Task4(p, 15, 16); |
| 18 | 1132 } |
| 1133 | |
| 1134 | |
| 35 | 1135 |
| 1136 CHARACTER* | |
| 1137 chara_state40(CHARACTER *p) //arm vulkan | |
| 18 | 1138 { |
| 57 | 1139 p->state_task = STATE40; |
| 58 | 1140 return Boss2Task4(p, 0, 0); |
| 18 | 1141 } |
| 1142 | |
| 1143 | |
| 35 | 1144 CHARACTER* |
| 1145 chara_state41(CHARACTER *p) //left arm up arm vulkan | |
| 18 | 1146 { |
| 57 | 1147 p->state_task = STATE41; |
| 58 | 1148 //if rand |
| 1149 return Boss2Task5(p, 0, 0); | |
| 18 | 1150 } |
| 1151 | |
| 1152 | |
| 38 | 1153 CHARACTER* |
| 1154 chara_state400(CHARACTER *p) | |
| 18 | 1155 { |
| 57 | 1156 p->state_task = STATE400; |
| 19 | 1157 return SimpleStateTask(p); |
| 18 | 1158 } |
| 1159 | |
| 1160 | |
| 34 | 1161 CHARACTER* |
| 1162 chara_state401(CHARACTER *p) | |
| 18 | 1163 { |
| 57 | 1164 p->state_task = STATE401; |
| 34 | 1165 return JikiContainerTask(p); |
| 18 | 1166 } |
| 1167 | |
| 1168 | |
| 34 | 1169 CHARACTER* |
| 1170 chara_state402(CHARACTER *p) | |
| 18 | 1171 { |
| 57 | 1172 p->state_task = STATE402; |
| 34 | 1173 return JikiContainerTask(p); |
| 18 | 1174 } |
| 1175 | |
| 1176 | |
| 35 | 1177 CHARACTER* |
| 1178 chara_state410(CHARACTER *p) | |
| 18 | 1179 { |
| 35 | 1180 kyeenemyno = p; |
| 57 | 1181 p->state_task = STATE411; |
| 35 | 1182 |
| 57 | 1183 state_check(p); |
| 35 | 1184 return p; |
| 18 | 1185 } |
| 1186 | |
| 1187 | |
| 35 | 1188 CHARACTER* |
| 1189 chara_state411(CHARACTER *p) | |
| 18 | 1190 { |
| 57 | 1191 p->state_task = STATE411; |
| 35 | 1192 return JikiContainerTask(p); |
| 1193 } | |
| 1194 | |
| 1195 | |
| 1196 CHARACTER* | |
| 1197 chara_state500(CHARACTER *p) | |
| 1198 { | |
| 57 | 1199 p->state_task = STATE500; |
| 35 | 1200 return Boss4Task(p); |
| 18 | 1201 } |
| 1202 | |
| 1203 | |
| 35 | 1204 CHARACTER* |
| 1205 chara_state501(CHARACTER *p) | |
| 18 | 1206 { |
| 57 | 1207 p->state_task = STATE501; |
| 35 | 1208 return sendContainerTask(p); |
| 18 | 1209 } |
| 1210 | |
| 1211 | |
| 35 | 1212 CHARACTER* |
| 1213 chara_state600(CHARACTER *p) | |
| 18 | 1214 { |
| 1215 kyeenemyno = p; | |
| 57 | 1216 p->state_task = STATE600; |
| 35 | 1217 return sendContainerTask(p); |
| 18 | 1218 } |
| 1219 | |
| 1220 | |
| 35 | 1221 CHARACTER* |
| 1222 chara_state601(CHARACTER *p) | |
| 18 | 1223 { |
| 57 | 1224 p->state_task = STATE601; |
| 58 | 1225 return Boss5Task1(p); |
| 18 | 1226 } |
| 1227 | |
| 1228 | |
| 35 | 1229 CHARACTER* |
| 1230 chara_state602(CHARACTER *p) | |
| 18 | 1231 { |
| 57 | 1232 p->state_task = STATE602; |
| 58 | 1233 return Boss5Task2(p); |
| 18 | 1234 } |