Mercurial > hg > Members > koba > t_dandy
annotate Character_state.c @ 70:cee55c8365e9 default tip
fix
| author | Kazuma |
|---|---|
| date | Thu, 19 May 2016 18:52:26 +0900 |
| parents | 2c85322348cf |
| 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" | |
| 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; | |
| 38 | 33 int counter = 0; |
| 34 | |
| 35 static | |
| 36 int get_num() | |
| 37 { | |
| 38 counter++; | |
| 39 counter %= 4; | |
| 40 return counter; | |
| 41 } | |
| 0 | 42 |
| 43 CHARACTER * noaction(CHARACTER *p) | |
| 44 { | |
| 45 p->state = noaction; | |
| 46 return p; | |
| 47 } | |
| 48 | |
| 19 | 49 CHARACTER * |
| 50 delete_chara(CHARACTER *p) | |
| 51 { | |
| 44 | 52 if (p->tama == FALSE) { |
| 53 printf("F%d: [%d] x=%f y=%f vx=%f vy=%f DELETE\n", filpcount, p->chara_id, p->x, p->y, p->vx, p->vy); | |
| 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; |
| 38 | 442 int rand = get_num(); |
|
6
9a92435eaee6
divide SG Dandy and Task Dandy.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
443 |
| 38 | 444 sf = rand % 4; |
| 0 | 445 if((sf == 0) || (sf == 1)) |
| 446 { | |
| 447 p->x = -35; | |
| 38 | 448 p->y = rand % (120 - 35); |
| 449 p->vx = (rand % 4 + 1); | |
| 450 p->vy = rand % 3 + 1; | |
| 0 | 451 p->state = chara_state23; |
| 452 } | |
| 70 | 453 if(sf == 2) |
| 0 | 454 { |
| 38 | 455 p->x = rand % 290; |
| 0 | 456 p->y = -30; |
| 38 | 457 p->vx = rand % 3 - 1; |
| 458 p->vy = (rand % 4 + 1); | |
| 0 | 459 p->state = chara_state23; |
| 460 } | |
| 461 if(sf == 3) | |
| 462 { | |
| 463 p->x = 320; | |
| 38 | 464 p->y = rand % (120 - 35); |
| 465 p->vx = (rand % 4 + 1) * -1; | |
| 466 p->vy = rand % 3 -1; | |
| 0 | 467 p->state = chara_state23; |
| 468 } | |
| 469 return p; | |
| 470 } | |
| 471 | |
| 472 CHARACTER * chara_state23(CHARACTER *p) | |
| 473 { | |
| 474 p=asteroid(p); | |
| 475 return p; | |
| 476 } | |
| 477 | |
| 478 CHARACTER * chara_state24(CHARACTER *p) | |
| 479 { | |
| 480 kyeenemyno = p; | |
| 481 tekino0 = 0; | |
| 482 enemy_part1 = p->next; | |
| 483 enemy_part2 = enemy_part1->next; | |
| 484 enemy_part3 = enemy_part2->next; | |
| 485 enemy_part4 = enemy_part3->next; | |
| 486 enemy_part5 = enemy_part4->next; | |
| 487 rinkx = 0; | |
| 488 rinky = 0; | |
| 489 rinkf1 = 0; | |
| 490 rinkf2 = 0; | |
| 491 p->state = chara_state25; | |
| 492 return p; | |
| 493 } | |
| 494 | |
| 495 CHARACTER * chara_state25(CHARACTER *p) | |
| 496 { | |
|
6
9a92435eaee6
divide SG Dandy and Task Dandy.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
497 int amari; |
| 38 | 498 int rand = get_num(); |
|
6
9a92435eaee6
divide SG Dandy and Task Dandy.
koba <koba@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
499 |
| 0 | 500 if(p->dt1 <= 360) |
| 501 { | |
| 502 p->x = Mycos(p->dt1) * 30 / SANKAKU + 82 + 32; | |
| 503 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; | |
| 504 } | |
| 505 if(p->dt1 > 360) | |
| 506 { | |
| 507 p->x = Mycos(p->dt1) * 30 * -1 /SANKAKU + 142 + 32; | |
| 508 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; | |
| 509 } | |
| 510 count++; | |
| 511 PutSprite(count, p->x - 42, p->y, 64); | |
| 38 | 512 amari = rand % 160; |
| 0 | 513 if((amari == 1) && (enemy_part5->f == TRUE)) |
| 514 { | |
| 515 p->state = chara_state26; | |
| 516 rinkf1 = 1; | |
| 517 } | |
| 518 if((amari == 2) && (enemy_part1->f == TRUE)) | |
| 519 { | |
| 520 p->state = chara_state27; | |
| 521 rinkf1 = 5; | |
| 522 rinkx = 0; | |
| 523 return p; | |
| 524 } | |
| 525 if((enemy_part5->f == TRUE) && (enemy_part1->f != TRUE)) | |
| 526 { | |
| 527 p->state = chara_state28; | |
| 528 } | |
| 529 p->dt1 += 3; | |
| 530 if(p->dt1 == 720) | |
| 531 { | |
| 532 p->dt1 = 0; | |
| 533 } | |
| 534 return p; | |
| 535 } | |
| 536 | |
| 537 CHARACTER * chara_state26(CHARACTER *p) | |
| 538 { | |
| 539 if((p->dt2 > 50) && (p->dt2 < 100)) | |
| 540 { | |
| 541 rinkf1 = 2; | |
| 542 } | |
| 543 if(p->dt2 > 100) | |
| 544 { | |
| 545 rinkf1 = 3; | |
| 546 } | |
| 547 if(p->dt2 == 400) | |
| 548 { | |
| 549 rinkf1 = 4; | |
| 550 } | |
| 551 count++; | |
| 552 PutSprite(count, p->x - 42, p->y, 64); | |
| 553 if(p->dt2 == 401) | |
| 554 { | |
| 555 p->dt2 = 0; | |
| 556 rinkf1 = 0; | |
| 557 p->state = chara_state25; | |
| 558 return p; | |
| 559 } | |
| 560 p->dt2++; | |
| 561 return p; | |
| 562 } | |
| 563 | |
| 564 CHARACTER * chara_state27(CHARACTER *p) //rocket punch | |
| 565 { | |
| 566 if((p->dt2 > 50) && (p->dt2 < 60) && (p->x > -24) && (p->y > -24)) | |
| 567 { | |
| 568 rinkf1 = 6; | |
| 569 rinkx -= 4; | |
| 570 p->x -= 4; | |
| 571 p->y -= 4; | |
| 572 } | |
| 573 if(p->dt2 == 80) | |
| 574 { | |
| 575 rinkf1 = 7; | |
| 576 } | |
| 577 if(p->dt2 == 81) | |
| 578 { | |
| 579 rinkf1 = 8; | |
| 580 } | |
| 581 if(p->dt2 == 124) | |
| 582 { | |
| 583 rinkf1 = 9; | |
| 584 } | |
| 585 if(p->dt2 == 400) | |
| 586 { | |
| 587 rinkf1 = 10; | |
| 588 } | |
| 589 if(p->dt2 == 444) | |
| 590 { | |
| 591 rinkf1 = 11; | |
| 592 } | |
| 593 if(p->dt2 == 500) | |
| 594 { | |
| 595 rinkf1 = 12; | |
| 596 } | |
| 597 if((p->dt2 > 80) && (p->dt2 < 200)) | |
| 598 { | |
| 599 if((rinkx != 0) && (p->dt2 % 2 == 1)) | |
| 600 { | |
| 601 rinkx++; | |
| 602 p->x++; | |
| 603 p->y++; | |
| 604 } | |
| 605 } | |
| 606 count++; | |
| 607 PutSprite(count, p->x - 32, p->y, 6); | |
| 608 if(rinkf1 == 12) | |
| 609 { | |
| 610 p->dt2 = 0; | |
| 611 rinkf1 = 0; | |
| 612 rinkx = 0; | |
| 613 p->state = chara_state25; | |
| 614 return p; | |
| 615 } | |
| 616 p->dt2++; | |
| 617 return p; | |
| 618 } | |
| 619 CHARACTER * chara_state28(CHARACTER *p) | |
| 620 { | |
| 38 | 621 int rand = get_num(); |
| 622 | |
| 0 | 623 if (p->dt1 <= 360) |
| 624 { | |
| 625 p->x = Mycos(p->dt1) * 30 / SANKAKU + 82 + 32; | |
| 626 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; | |
| 627 } | |
| 628 if (p->dt1 > 360) | |
| 629 { | |
| 630 p->x = Mycos(p->dt1) * 30 * -1 / SANKAKU + 142 + 32; | |
| 631 p->y = Mysin(p->dt1) * 30 / SANKAKU + 30; | |
| 632 } | |
| 633 count++; | |
| 634 PutSprite(count, p->x - 42, p->y, 64); | |
| 635 if (p->dt1 % 30 == 3) | |
| 636 { | |
| 637 Putenemy(24, p->x + 14, | |
| 638 p->y + 14, | |
| 38 | 639 (rand % 5 + 0.5) * (rand % 2 == |
| 0 | 640 1 ? -1 : 1), |
| 38 | 641 (rand % 5 + 0.5) * (rand % 2 == |
| 0 | 642 1 ? -1 : 1), chara_state29); |
| 643 } | |
| 644 p->dt1 += 3; | |
| 645 return p; | |
| 646 } | |
| 647 | |
| 648 | |
| 649 CHARACTER * chara_state29(CHARACTER *p) | |
| 650 { | |
| 651 p->x += p->vx; | |
| 652 p->y += p->vy; | |
| 653 if(p->dt1 % 18 == 1) | |
| 654 { | |
| 655 Puttama(0, p->x, p->y); | |
| 656 } | |
| 657 p->dt1++; | |
| 658 return p; | |
| 659 } | |
| 660 | |
| 661 | |
| 662 CHARACTER * chara_state30(CHARACTER *p) | |
| 663 { | |
| 664 p->x = p->x - 32; | |
| 665 p->y = p->y; | |
| 666 return p; | |
| 667 } | |
| 668 | |
| 669 CHARACTER * chara_state31(CHARACTER *p) //right hand | |
| 670 { | |
| 671 | |
| 672 if((enemy_part3->f == FALSE) || (kyeenemyno->f == FALSE)) | |
| 673 { | |
| 674 Bom(p->x, p->y); | |
| 675 p->f = FALSE; | |
| 676 p->state = delete_chara; | |
| 677 p->collision = noaction; | |
| 678 return p; | |
| 679 } | |
| 680 | |
| 681 if(rinkf1 == 0) | |
| 682 { | |
| 683 p->x = kyeenemyno->x + 40; | |
| 684 p->y = kyeenemyno->y + 28; | |
| 685 p->dt2 = 0; | |
| 686 } | |
| 687 if(rinkf1 == 5) | |
| 688 { | |
| 689 p->x = kyeenemyno->x + 52; | |
| 690 p->y = kyeenemyno->y; | |
| 691 count++; | |
| 692 PutSprite(count, p->x - 4, p->y - 20, 80 + p->dt2 % 4); | |
| 693 p->dt2++; | |
| 694 } | |
| 695 if(rinkf1 == 6) | |
| 696 { | |
| 697 if(p->y < 240 - 40) | |
| 698 { | |
| 699 p->y += 6; | |
| 700 } | |
| 701 else | |
| 702 { | |
| 703 return p; | |
| 704 } | |
| 705 count++; | |
| 706 PutSprite(count, p->x - 4, p->y - 20, 90 + p->dt2 % 4); | |
| 707 p->dt2++; | |
| 708 } | |
| 709 if(rinkf1 == 7) | |
| 710 { | |
| 711 Putenemy(22, p->x + 14, p->y + 14, 0, 0, chara_state40); | |
| 712 return p; | |
| 713 } | |
| 714 if(rinkf1 == 11) | |
| 715 { | |
| 716 if(p->y + 20 != p->y) | |
| 717 { | |
| 718 p->y--; | |
| 719 } | |
| 720 else | |
| 721 { | |
| 722 return p; | |
| 723 } | |
| 724 count++; | |
| 725 PutSprite(count, p->x + 8, p->y + 44, 58 + p->dt2 % 4); | |
| 726 p->dt2++; | |
| 727 } | |
| 728 return p; | |
| 729 } | |
| 730 | |
| 731 | |
| 732 CHARACTER * chara_state32(CHARACTER *p) //left hand | |
| 733 { | |
| 734 if ((enemy_part4->f == FALSE) | |
| 735 || (kyeenemyno->f == FALSE)) | |
| 736 { | |
| 737 Bom(p->x, p->y); | |
| 738 p->f = FALSE; | |
| 739 p->state = delete_chara; | |
| 740 p->collision = noaction; | |
| 741 return p; | |
| 742 } | |
| 743 p->x = kyeenemyno->x - 40; | |
| 744 p->y = kyeenemyno->y + 28; | |
| 745 if (rinkf1 == 5) | |
| 746 { | |
| 747 p->x = kyeenemyno->x - 24 + 4; | |
| 748 p->y = kyeenemyno->y + 28; | |
| 749 p->charano = enemystate[20].charano; | |
| 750 } | |
| 751 if (rinkf1 == 11) | |
| 752 { | |
| 753 p->charano = enemystate[14].charano; | |
| 754 } | |
| 755 if (rinkf1 == 7) | |
| 756 { | |
| 757 Putenemy(23, p->x + 14, | |
| 758 p->y + 14, 0, 0, chara_state41); | |
| 759 // rinkf1=8; | |
| 760 return p; | |
| 761 } | |
| 762 return p; | |
| 763 } | |
| 764 | |
| 765 | |
| 766 CHARACTER * chara_state33(CHARACTER *p) // right shoulder | |
| 767 { | |
| 768 if (kyeenemyno->f == FALSE) | |
| 769 { | |
| 770 Bom(p->x, p->y); | |
| 771 p->f = FALSE; | |
| 772 p->state = delete_chara; | |
| 773 p->collision = noaction; | |
| 774 return p; | |
| 775 } | |
| 776 p->x = kyeenemyno->x + 32; | |
| 777 p->y = kyeenemyno->y; | |
| 778 if (rinkf1 == 5) | |
| 779 { | |
| 780 p->x = kyeenemyno->x + 32 - 4; | |
| 781 p->y = kyeenemyno->y; | |
| 782 p->charano = enemystate[19].charano; | |
| 783 } | |
| 784 if (rinkf1 == 6) | |
| 785 { | |
| 786 p->charano = enemystate[11].charano; | |
| 787 } | |
| 788 return p; | |
| 789 } | |
| 790 | |
| 791 | |
| 792 CHARACTER * chara_state34(CHARACTER *p) //left shoulder | |
| 793 { | |
| 794 if (kyeenemyno->f == FALSE) | |
| 795 { | |
| 796 Bom(p->x, p->y); | |
| 797 p->f = FALSE; | |
| 798 p->state = delete_chara; | |
| 799 p->collision = noaction; | |
| 800 return p; | |
| 801 } | |
| 802 p->x = kyeenemyno->x - 32; | |
| 803 p->y = kyeenemyno->y; | |
| 804 if (rinkf1 == 5) | |
| 805 { | |
| 806 p->charano = enemystate[21].charano; | |
| 807 } | |
| 808 if (rinkf1 == 6) | |
| 809 { | |
| 810 p->charano = enemystate[12].charano; | |
| 811 } | |
| 812 return p; | |
| 813 } | |
| 814 | |
| 815 CHARACTER * chara_state35(CHARACTER *p) // bust | |
| 816 { | |
| 817 if (kyeenemyno->f == FALSE) | |
| 818 { | |
| 819 Bom(p->x, p->y); | |
| 820 p->f = FALSE; | |
| 821 p->state = delete_chara; | |
| 822 p->collision = noaction; | |
| 823 return p; | |
| 824 } | |
| 825 p->x = kyeenemyno->x; | |
| 826 p->y = kyeenemyno->y + 32; | |
| 827 if (rinkf1 == 1) | |
| 828 { | |
| 829 p->charano = enemystate[16].charano; | |
| 830 } | |
| 831 if (rinkf1 == 2) | |
| 832 { | |
| 833 count++; | |
| 834 PutSprite(count, p->x - 10, | |
| 835 p->y + 16, | |
| 836 58 + p->dt2 % 4); | |
| 837 count++; | |
| 838 PutSprite(count, p->x + 10, | |
| 839 p->y + 16, | |
| 840 58 + p->dt2 % 4); | |
| 841 p->dt2++; | |
| 842 } | |
| 843 if (rinkf1 == 3) | |
| 844 { | |
| 845 count++; | |
| 846 PutSprite(count, p->x - 10, | |
| 847 p->y + 16, | |
| 848 58 + p->dt2 % 4); | |
| 849 count++; | |
| 850 PutSprite(count, p->x + 10, | |
| 851 p->y + 16, | |
| 852 58 + p->dt2 % 4); | |
| 853 if (p->dt2 % 20 == 1) | |
| 854 { | |
| 855 Puttama(7, p->x, p->y + 16); | |
| 856 Puttama(7, p->x + 20, | |
| 857 p->y + 16); | |
| 858 } | |
| 859 p->dt2++; | |
| 860 } | |
| 861 if (rinkf1 == 4) { | |
| 862 p->charano = enemystate[15].charano; | |
| 863 p->dt2 = 0; | |
| 864 } | |
| 865 return p; | |
| 866 } | |
| 867 | |
| 868 | |
| 869 CHARACTER * chara_state40(CHARACTER *p) //arm vulkan | |
| 870 { | |
| 871 if (enemy_part1->f == FALSE) | |
| 872 { | |
| 873 Bom(p->x, p->y); | |
| 874 p->f = FALSE; | |
| 875 p->state = delete_chara; | |
| 876 p->collision = noaction; | |
| 877 return p; | |
| 878 } | |
| 879 if ((rinkf1 == 8) && (p->dt1 % 3 == 1)) | |
| 880 { | |
| 881 if ((p->dt2 < 16)) | |
| 882 { | |
| 883 p->dt2++; | |
| 884 DefSprite(76, "boss2_rightarm_b", 16, p->dt2, 480, boss); | |
| 885 } | |
| 886 else | |
| 887 { | |
| 888 // rinkf1=9; | |
| 889 return p; | |
| 890 } | |
| 891 } | |
| 892 if (rinkf1 == 9) | |
| 893 { | |
| 894 if (p->dt1 % 15 == 1) | |
| 895 { | |
| 896 Puttama(8, p->x, p->y); | |
| 897 } | |
| 898 } | |
| 899 if (rinkf1 == 10) | |
| 900 { | |
| 901 if (p->dt2 != 0) | |
| 902 { | |
| 903 p->dt2--; | |
| 904 DefSprite(76, "boss2_rightarm_b", 16, p->dt2, 480, boss); | |
| 905 } | |
| 906 else | |
| 907 { | |
| 908 p->f = FALSE; | |
| 909 p->state = delete_chara; | |
| 910 p->collision = noaction; | |
| 911 // rinkf1=11; | |
| 912 } | |
| 913 } | |
| 914 p->dt1++; | |
| 915 return p; | |
| 916 } | |
| 917 | |
| 918 | |
| 919 CHARACTER * chara_state41(CHARACTER *p) //left arm up arm vulkan | |
| 920 { | |
| 38 | 921 |
| 0 | 922 if (enemy_part2->f == FALSE) |
| 923 { | |
| 924 Bom(p->x, p->y); | |
| 925 p->f = FALSE; | |
| 926 p->state = delete_chara; | |
| 927 p->collision = noaction; | |
| 928 return p; | |
| 929 } | |
| 930 p->x = kyeenemyno->x - 20 - 7; | |
| 931 p->y = kyeenemyno->y + 28 + 15; | |
| 932 if ((rinkf1 == 8) && (p->dt1 % 3 == 1)) | |
| 933 { | |
| 934 if ((p->dt2 < 16)) | |
| 935 { | |
| 936 p->dt2++; | |
| 937 DefSprite(77, "boss2_leftarmbattery", p->dt2, 16, 480, boss); /*左腕アップアーム砲 */ | |
| 938 } | |
| 939 else | |
| 940 { | |
| 941 rinkf1 = 9; | |
| 942 return p; | |
| 943 } | |
| 944 } | |
| 945 if (rinkf1 == 9) | |
| 946 { | |
| 947 if (p->dt1 % 15 == 1) | |
| 948 { | |
| 70 | 949 Puttama(9 + rand() % 2, p->x, p->y); |
| 0 | 950 } |
| 951 } | |
| 952 if (rinkf1 == 10) | |
| 953 { | |
| 954 if (p->dt2 != 0) | |
| 955 { | |
| 956 p->dt2--; | |
| 957 DefSprite(77, "boss2_leftarmbattery", p->dt2, 16, 480, boss); | |
| 958 } | |
| 959 else | |
| 960 { | |
| 961 p->f = FALSE; | |
| 962 p->state = delete_chara; | |
| 963 p->collision = noaction; | |
| 964 return p; | |
| 965 // rinkf1=11; | |
| 966 } | |
| 967 } | |
| 968 p->dt1++; | |
| 969 return p; | |
| 970 } | |
| 971 | |
| 972 | |
| 973 CHARACTER * chara_state400(CHARACTER *p) | |
| 974 { | |
| 975 p->vy++; | |
| 976 p->y += p->vy / 4; | |
| 977 p->state = chara_state400; | |
| 978 return p; | |
| 979 } | |
| 980 | |
| 981 | |
| 982 CHARACTER * chara_state401(CHARACTER *p) | |
| 983 { | |
| 984 p->vx++; | |
| 985 p->x += p->vx / 8; | |
| 986 if (p->x > (jiki.x - 32)) | |
| 987 { | |
| 988 p->vy--; | |
| 989 } | |
| 990 p->y += p->vy / 8; | |
| 991 if (p->dt1 % 50 == 37) | |
| 992 { | |
| 993 Puttama(1, p->x + 8, p->y + 24); | |
| 994 } | |
| 995 p->dt1++; | |
| 996 return p; | |
| 997 } | |
| 998 | |
| 999 | |
| 1000 CHARACTER * chara_state402(CHARACTER *p) | |
| 1001 { | |
| 1002 p->vx--; | |
| 1003 p->x += p->vx / 8; | |
| 1004 if (p->x < (jiki.x + 32)) | |
| 1005 { | |
| 1006 p->vy--; | |
| 1007 } | |
| 1008 p->y += p->vy / 8; | |
| 1009 if (p->dt1 % 50 == 37) | |
| 1010 { | |
| 1011 Puttama(1, p->x + 8, p->y + 24); | |
| 1012 } | |
| 1013 p->dt1++; | |
| 1014 return p; | |
| 1015 } | |
| 1016 | |
| 1017 | |
| 1018 CHARACTER * chara_state410(CHARACTER *p) | |
| 1019 { | |
| 1020 kyeenemyno = p; | |
| 1021 p->state = chara_state411; | |
| 1022 return p; | |
| 1023 } | |
| 1024 | |
| 1025 | |
| 1026 CHARACTER * chara_state411(CHARACTER *p) | |
| 1027 { | |
| 1028 if (p->dt2 > 356) | |
| 1029 { | |
| 1030 p->vx = -1; | |
| 1031 } | |
| 1032 if (p->dt2 < -398) | |
| 1033 { | |
| 1034 p->vx = 1; | |
| 1035 } | |
| 1036 if ((p->dt1) % 62 == 0) | |
| 1037 Putenemy(41, | |
| 1038 p->x, | |
| 1039 p->y, | |
| 1040 (int) -Mycos(p->dt1 / 16) * 4 / | |
| 1041 SANKAKU, | |
| 1042 (int) -Mysin(p->dt1 / 16) * 4 / | |
| 1043 SANKAKU, chara_state7); | |
| 1044 if ((p->dt1) % 13 == 0) | |
| 1045 Puttama(11, p->x + 32, | |
| 1046 p->y + 32); | |
| 1047 | |
| 1048 p->dt2 += p->vx; | |
| 1049 p->dt1 += p->dt2 / 4; | |
| 1050 | |
| 1051 p->x = jiki.x - 16 + | |
| 1052 Mycos(p->dt1 / 16) * 128 / SANKAKU; | |
| 1053 p->y = jiki.y - 16 + | |
| 1054 Mysin(p->dt1 / 16) * 128 / SANKAKU; | |
| 1055 if (p->x < 0) | |
| 1056 { | |
| 1057 p->x = 0; | |
| 1058 } | |
| 1059 if (p->x > 260) | |
| 1060 { | |
| 1061 p->x = 260; | |
| 1062 } | |
| 1063 if (p->y < 0) | |
| 1064 { | |
| 1065 p->y = 0; | |
| 1066 } | |
| 1067 if (p->y > 232) | |
| 1068 { | |
| 1069 p->y = 232; | |
| 1070 } | |
| 1071 return p; | |
| 1072 } | |
| 1073 | |
| 1074 | |
| 1075 CHARACTER * chara_state500(CHARACTER *p) | |
| 1076 { | |
| 38 | 1077 int rand = get_num(); |
| 0 | 1078 p->s = 0; |
| 1079 | |
| 1080 kyeenemyno = p; | |
| 1081 p->dt2++; | |
| 1082 p->dt2 %= 512; | |
| 1083 p->dt1++; | |
| 1084 count++; | |
| 1085 DefSpriteEx(100, 16, 16); | |
| 1086 // PutSprite(count, enemy[tekino].x + 16, | |
| 1087 // enemy[tekino].y + 16, 100); | |
| 1088 PutSpriteEx(100, p->x + 16, p->y + 16, 2, 2, p->dt1); | |
| 1089 | |
| 1090 if (p->dt1 % (5 + p->dt2 / 8) == 1) { | |
| 38 | 1091 if (rand % 2 == 1) |
| 0 | 1092 Putenemy(24, p->x, p->y, |
| 38 | 1093 (rand % 5 + 0.5) * (rand % 2 == |
| 0 | 1094 1 ? -1 : 1), |
| 38 | 1095 (rand % 5 + 0.5) * (rand % 2 == |
| 0 | 1096 1 ? -1 : 1), chara_state501); |
| 1097 else | |
| 38 | 1098 Putenemy(rand % 2 + 1, p->x, |
| 0 | 1099 p->y, |
| 1100 (int) Mycos(p->dt1 / 4) * 4 / | |
| 1101 SANKAKU, | |
| 1102 (int) -Mysin(p->dt1 / 4) * 4 / | |
| 1103 SANKAKU, chara_state501); | |
| 1104 } | |
| 1105 if (p->dt1 == 50) { | |
| 1106 /*Putenemy(44,0,0,1,1,411); */ | |
| 1107 } | |
| 1108 return p; | |
| 1109 } | |
| 1110 | |
| 1111 | |
| 1112 CHARACTER * chara_state501(CHARACTER *p) | |
| 1113 { | |
| 1114 p->x += p->vx; | |
| 1115 p->y += p->vy; | |
| 1116 if(p->dt1 % 32 == 1) | |
| 1117 { | |
| 1118 Puttama(11, p->x, p->y); | |
| 1119 } | |
| 1120 p->dt1++; | |
| 38 | 1121 printf("x = %f, y = %f, vx = %f, vy = %f\n",p->x, p->y, p->vx, p->vy); |
| 0 | 1122 return p; |
| 1123 } | |
| 1124 | |
| 1125 | |
| 1126 CHARACTER * chara_state600(CHARACTER *p) | |
| 1127 { | |
| 1128 kyeenemyno = p; | |
| 1129 p->dt1 += 30; | |
| 1130 p->dt2++; | |
| 1131 p->dt1 %= 360; | |
| 1132 p->x += Mycos(p->dt1) * 4 / SANKAKU; | |
| 1133 p->y += Mysin(p->dt1) * 4 / SANKAKU; | |
| 1134 Puttama(11, p->x + 16, p->y + 16); | |
| 1135 Puttama(11, p->x + 32, p->y + 48); | |
| 1136 Puttama(11, p->x + 48, p->y + 16); | |
| 1137 if (p->dt2 > 240) | |
| 1138 p->state = chara_state601; | |
| 1139 if (p->x < 0) | |
| 1140 p->x = 0; | |
| 1141 if (p->x > 260) | |
| 1142 p->x = 260; | |
| 1143 if (p->y < 0) | |
| 1144 p->y = 0; | |
| 1145 if (p->y > 232) | |
| 1146 p->y = 232; | |
| 1147 return p; | |
| 1148 } | |
| 1149 | |
| 1150 | |
| 1151 CHARACTER * chara_state601(CHARACTER *p) | |
| 1152 { | |
| 38 | 1153 int rand = get_num(); |
| 0 | 1154 p->dt2++; |
| 1155 if (p->x < jiki.x) | |
| 1156 p->vx++; | |
| 1157 if (p->x > jiki.x) | |
| 1158 p->vx--; | |
| 1159 p->x += p->vx; | |
| 38 | 1160 Putenemy(6, p->x + 16 + rand % 32, |
| 1161 p->y, 0, rand % 4, chara_state400); | |
| 0 | 1162 if (p->x < 0) |
| 1163 p->x = 0; | |
| 1164 if (p->x > 260) | |
| 1165 p->x = 260; | |
| 1166 if (p->y < 0) | |
| 1167 p->y = 0; | |
| 1168 if (p->y > 232) | |
| 1169 p->y = 232; | |
| 1170 if (p->dt2 > 800) { | |
| 1171 p->state = chara_state602; | |
| 1172 } | |
| 1173 return p; | |
| 1174 } | |
| 1175 | |
| 1176 | |
| 1177 CHARACTER * chara_state602(CHARACTER *p) | |
| 1178 { | |
| 38 | 1179 int rand = get_num(); |
| 1180 | |
| 0 | 1181 p->dt2++; |
| 1182 Putenemy(24, p->x + 14, p->y + 14, | |
| 38 | 1183 (rand % 5 + 0.5) * (rand % 2 == 1 ? -1 : 1), |
| 1184 (rand % 5 + 0.5) * (rand % 2 == 1 ? -1 : 1), | |
| 0 | 1185 chara_state29); |
| 1186 if (p->dt2 > 1024) { | |
| 1187 p->state = chara_state600; | |
| 1188 p->dt2 = 0; | |
| 1189 } | |
| 1190 return p; | |
| 1191 } | |
| 1192 | |
| 1193 | |
| 1194 CHARACTER * asteroid(CHARACTER *p) | |
| 1195 { | |
| 1196 int i; | |
| 1197 | |
| 1198 asteroiddt[asteroidi] = p; | |
| 1199 // if(asteroidi==0) | |
| 1200 // { | |
| 1201 p->x += p->vx; | |
| 1202 p->y += p->vy; | |
| 1203 // } | |
| 1204 if (asteroidi > 0) { | |
| 1205 for (i = 0; i < asteroidi; i++) { | |
| 1206 if ((asteroiddt[i]->x + 32 > p->x) | |
| 1207 && (p->x + 32 > asteroiddt[i]->x) | |
| 1208 && (asteroiddt[i]->y + 32 > p->y) | |
| 1209 && (asteroiddt[i]->y < p->y + 32)) { | |
| 1210 p->vx *= -1; | |
| 1211 p->vy *= -1; | |
| 1212 } | |
| 1213 } | |
| 1214 } | |
| 1215 asteroidi++; | |
| 1216 return p; | |
| 1217 } |