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