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