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