Awars III/FieldView.m

   1 //
   2 //  FieldView.m
   3 //  Awars III
   4 //
   5 //  Created by Killery on 2013/02/22.
   6 //  Copyright (c) 2013年 Killery. All rights reserved.
   7 //
   8
   9 #import "FieldView.h"
  10 #import "FieldScene.h"
  11
  12 @implementation FieldView
  13 -(BOOL)isFlipped{
  14     return YES;
  15 }
  16
  17 - (id)initWithFrame:(NSRect)frame
  18 {
  19     self = [super initWithFrame:frame];
  20     if (self) {
  21         time  = [NSTimer
  22                  scheduledTimerWithTimeInterval:0.01
  23                  target:self
  24                  selector:@selector(EventLoopFV:)
  25                  userInfo:nil
  26                  repeats:YES
  27                  ];
  28         chip = [[self LoadImage:@"マス.png"] retain];
  29         chipSelect = [[self LoadImage:@"セレクター.png"] retain];
  30         chipMove = [[self LoadImage:@"セレクター（移動）.png"] retain];
  31         chipAttack = [[self LoadImage:@"セレクター（攻撃）.png"] retain];
  32         chipTarget = [[self LoadImage:@"セレクター（選択）.png"] retain];
  33         chipSummon = [[self LoadImage:@"セレクター（攻撃）.png"] retain];
  34         chipTeam0 = [[self LoadImage:@"ハイライト（青）.png"] retain];
  35         chipTeam1 = [[self LoadImage:@"ハイライト（黄）.png"] retain];
  36         chipTeam2 = [[self LoadImage:@"ハイライト（赤）.png"] retain];
  37         chipUtarg = [[self LoadImage:@"ターゲット（目標）.png"] retain];
  38
  39         n1 = [[self LoadImage:@"num1"] retain];
  40         n2 = [[self LoadImage:@"num2"] retain];
  41         n3 = [[self LoadImage:@"num3"] retain];
  42         n4 = [[self LoadImage:@"num4"] retain];
  43         n5 = [[self LoadImage:@"num5"] retain];
  44         n6 = [[self LoadImage:@"num6"] retain];
  45         n7 = [[self LoadImage:@"num7"] retain];
  46         n8 = [[self LoadImage:@"num8"] retain];
  47         n9 = [[self LoadImage:@"num9"] retain];
  48         n10 = [[self LoadImage:@"num10"] retain];
  49         n11 = [[self LoadImage:@"num11"] retain];
  50         n12 = [[self LoadImage:@"num12"] retain];
  51         n13 = [[self LoadImage:@"num13"] retain];
  52         n14 = [[self LoadImage:@"num14"] retain];
  53         n15 = [[self LoadImage:@"num15"] retain];
  54         n16 = [[self LoadImage:@"num16"] retain];
  55         n17 = [[self LoadImage:@"num17"] retain];
  56         n18 = [[self LoadImage:@"num18"] retain];
  57         n19 = [[self LoadImage:@"num19"] retain];
  58         n20 = [[self LoadImage:@"num20"] retain];
  59
  60         g_shallowDepth = 1002;
  61
  62     }
  63
  64     return self;
  65 }
  66
  67
  68 -(void)EventLoopFV:(NSTimer*)timer{
  69
  70     //if(unitBreak) NSLog(@"unitBreakAtkrange %d", unitBreak->atkRange);
  71
  72
  73     if(evInitMap) {evInitMap = false;
  74         //[self loadMesh:SC[storyNumb].nameMAP index:scenarioNumb];
  75         /*
  76          MapView *MV = [MapView alloc];
  77          [MV loadMapChip];
  78          */
  79         NSRect seRect = NSMakeRect(0, 0, chipWidth*32, chipHeight*32);
  80         [self setFrame:seRect];
  81         chipNum[0][0] = 0;
  82
  83     }
  84     static int i0 = 0;
  85     static int movePlus = 0;
  86     static int cPosX;
  87     static int cPosY;
  88
  89     static int chipTargetCnt = 0;
  90
  91     if(endGameCondition){
  92         i0 = 0;
  93         unitMoveBugFixFlag = false;
  94         unitMoveEndFlag = false;
  95         submitFlag = true;
  96         stanbyFlag = false;
  97     }
  98
  99     chipTargetCnt++;
 100
 101     if(chipTargetCnt > 60){
 102
 103         if(!chipTargetFlag) chipTargetFlag = true;
 104         else chipTargetFlag = false;
 105         chipTargetCnt = 0;
 106     }
 107
 108     if(!Uselected)
 109         Uselected = unitBreak;
 110
 111     if(stanbyFlag){
 112
 113
 114         if(!submitFlag) movePlus += 4;
 115         if( i0 < g_shallowDepth && movePlus >= 32 && !submitFlag)
 116         {
 117             cPosX = g_moveRoute[i0][1]*32;
 118             cPosY = g_moveRoute[i0][0]*32;
 119             i0++;
 120             movePlus = 0;
 121             currentPosX = cPosX;
 122             currentPosY = cPosY;
 123             unitMoveBugFixFlag = true;
 124
 125             if(i0 == 2) {
 126                 unitNum[g_moveRoute[0][1]][g_moveRoute[0][0]] = -1;
 127                 unitTeam[g_moveRoute[0][1]][g_moveRoute[0][0]] = -1;
 128                 loadNum[g_moveRoute[0][1]][g_moveRoute[0][0]] = -1;
 129             }
 130         }
 131         if(i0 >= g_shallowDepth) {i0--;
 132
 133             unitNum[g_moveRoute[i0][1]][g_moveRoute[i0][0]] = Uselected->C.chipNumb;
 134             loadNum[g_moveRoute[i0][1]][g_moveRoute[i0][0]] = Uselected->CL.chipNumb;
 135             unitTeam[g_moveRoute[i0][1]][g_moveRoute[i0][0]] = Uselected->team;
 136
 137             submitFlag = true;
 138             unitMoveEndFlag = true;
 139             unitMoveBugFixFlag = false;
 140             pussyLoopFlag = false;
 141             if(UA) cpuIsAttackingFlag = true;
 142             i0 = 0;
 143
 144             U = UTop;
 145             while(U){
 146                 if(g_moveRoute[0][1] == U->x && g_moveRoute[0][0] == U->y){
 147                     U->x = g_moveRoute[g_shallowDepth-1][1];
 148                     U->y = g_moveRoute[g_shallowDepth-1][0];
 149                     break;
 150                 }
 151                 U = U->next;
 152             }
 153
 154             if(U) unitBreak = U;
 155
 156             U = UTop;
 157         }
 158     }else{
 159         submitFlag = false;
 160         i0 = 0;
 161         unitMoveBugFixFlag = false;
 162
 163         for(int j = 0;j < g_shallowDepth;j++){
 164             g_moveRoute[j][0] = -1;
 165             g_moveRoute[j][1] = -1;
 166         }
 167     }
 168
 169     U = UTop;
 170     if(initStatusFlag)
 171         while (U) {
 172
 173             if(U->dead || (U->chipNumber >= 0 && U->C.S_C.HP <= 0)){
 174                 U->dead = true;
 175                 unitNum[U->x][U->y] = -1;
 176                 unitTeam[U->x][U->y] = -1;
 177                 U->x = -1;
 178                 U->y = -1;
 179             }
 180             U = U->next;
 181         }
 182     U = UTop;
 183
 184     U = UTop;
 185     if(initStatusFlag)
 186         while (U) {
 187
 188             if(U->dead || (U->chipNumberL >= 0 && U->CL.S_C.HP <= 0)){
 189                 U->dead = true;
 190                 loadNum[U->x][U->y] = -1;
 191                 unitTeam[U->x][U->y] = -1;
 192                 U->x = -1;
 193                 U->y = -1;
 194             }
 195             U = U->next;
 196         }
 197     U = UTop;
 198
 199     ////////////バグフィクス///////////////////
 200     if(UTop && initStatusFlag)
 201         for (int i = 1;i <= chipWidth;i++) {
 202             for (int k = 1;k <= chipHeight;k++) {
 203
 204                 bool noFixFlag = false;
 205                 U = UTop;
 206                 while(U){
 207
 208                     if((U->x == i && U->y == k)){
 209                         noFixFlag = true;
 210                         break;
 211                     }
 212
 213                     U = U->next;
 214                 }U = UTop;
 215
 216                 if(!noFixFlag){
 217                     unitNum[i][k] = -1;
 218                     loadNum[i][k] = -1;
 219                     unitTeam[i][k] = -1;
 220                 }
 221             }
 222         }
 223
 224     if(1){
 225         U = UTop;
 226         slctedUnitNum = 0;
 227         while(U != NULL){
 228             if(U->x == possionX && U->y == possionY){
 229                 break;
 230             }
 231             slctedUnitNum++;
 232             U = U->next;
 233         }
 234         if(!U) slctedUnitNum = -1;
 235         U = UTop;
 236
 237     }
 238
 239     if(dcRdy){
 240         U = UTop;
 241         for (int i = 0; i < slctedUnitNum; i++) {
 242             U = U->next;
 243         }
 244         if(U->chipNumberL < 0){
 245             U = UTop;
 246
 247             while(U && !(possionX == U->x && possionY == U->y)){
 248                 U = U->next;
 249             }
 250
 251             [self LookupAttackRange:possionY startY:possionX aPiece:&U->C turnSide:YES];
 252             U = UTop;
 253         }else {
 254             U = UTop;
 255             [self LookupAttackRange2:possionY startY:possionX aPiece:&LC[loadNum[possionX][possionY]] turnSide:YES];
 256         }
 257         U = UTop;
 258
 259         dcRdy = false;
 260     }else if(dcRdy2){
 261         U = UTop;
 262         int i = 1;
 263         while(U && AUN[1] > i){i++;
 264             U = U->next;
 265         }
 266         attackExceptNumber = U->number;
 267         if(U->chipNumberL < 0){
 268
 269             [self LookupAttackRangeExtent:possionY startY:possionX aPiece:&U->C turnSide:YES];
 270             U = UTop;
 271         }else {
 272
 273             [self LookupAttackRangeExtent2:possionY startY:possionX aPiece:&U->CL turnSide:YES];
 274         }
 275         U = UTop;
 276
 277         dcRdy2 = false;
 278     }
 279
 280
 281
 282     if(bclRdy){
 283         U = UTop;
 284         int i = 1;
 285         while(U && AUN[1] > i){i++;
 286             U = U->next;
 287         }
 288
 289         buildNum[possionX][possionY] = U->C.S->list[crBCL]-1;
 290
 291         U = UTop;
 292         bclRdy = false;
 293
 294         createFlag = false;
 295     }
 296
 297     if(Uselected)
 298         if(Uselected->dead){
 299             Uselected = NULL;
 300         }
 301
 302     if(cslRdy){
 303         [self LookupSummonRange:possionY startY:possionX aPiece:&UC[unitNum[possionX][possionY]] turnSide:YES];
 304         cslRdy = false;
 305     }
 306
 307     if(buildCaptureFlag && unitMoveEndFlag){
 308
 309         B = BTop;
 310         while (B) {
 311             if(B->x == Uselected->x && B->y == Uselected->y){
 312                 if(Uselected->team == 0) B->team = 0;
 313                 if(Uselected->team == 1) B->team = 1;
 314                 if(Uselected->team == 2) B->team = 2;
 315                 unitColorInitFlag = true;
 316             }
 317             B = B->next;
 318         }B = BTop;
 319
 320         buildCaptureFlag = false;
 321     }
 322
 323     if(unitColorInitFlag){
 324         U = UTop;
 325         while(U){
 326             if(!U->CL.nameID){
 327                 if(U->team == 0)
 328                     U->img = [self SetImageColor:U->C.img color:0];
 329                 if(U->team == 1)
 330                     U->img = [self SetImageColor:U->C.img color:1];
 331                 if(U->team == 2)
 332                     U->img = [self SetImageColor:U->C.img color:2];
 333             }else{
 334                 if(U->team == 0)
 335                     U->img = [self SetImageColor:U->CL.img color:0];
 336                 if(U->team == 1)
 337                     U->img = [self SetImageColor:U->CL.img color:1];
 338                 if(U->team == 2)
 339                     U->img = [self SetImageColor:U->CL.img color:2];
 340             }
 341
 342
 343
 344             U = U->next;
 345         }U = UTop;
 346
 347         B = BTop;
 348         while(B){
 349             if(B->team < 0) B->img = B->C.img;
 350             if(B->team == 0)
 351                 B->img = [self SetImageColor:B->C.img color:0];
 352             if(B->team == 1)
 353                 B->img = [self SetImageColor:B->C.img color:1];
 354             if(B->team == 2)
 355                 B->img = [self SetImageColor:B->C.img color:2];
 356             B = B->next;
 357         }B = BTop;
 358
 359         unitColorInitFlag = false;
 360
 361     }
 362
 363
 364     if(cpuAImodeflag){
 365
 366         //if(unitBreak->CPU) cpuTurnEndFlag = false;
 367
 368         if(!cpuTurnEndFlag){
 369             [self modeCPUturn];
 370         }
 371
 372     }
 373
 374
 375     if(fieldViewBattleInitFlag){
 376
 377     }
 378
 379
 380
 381     if(waitSwtichFlag){
 382         static int wcnt = 0;
 383         wcnt++;
 384         if(wcnt >= waitinTime*100){
 385             waitAllOverFlag = true;
 386             wcnt = 0;
 387         }
 388     }
 389
 390     chipNum[0][0]= 0;
 391     [self setNeedsDisplay:YES];
 392
 393     if(initStatusFlag)
 394         battleBegin = true;
 395
 396
 397
 398     if(unitBreak){
 399         if(unitBreak->dead){
 400             unitNum[unitBreak->x][unitBreak->y] = -1;
 401             unitBreak->C.S_C.WT = 999999;
 402             //wtRdy = false;
 403             stanbyFlag = true;
 404             wtMovedFlag = true;
 405         }
 406
 407     }
 408
 409 }
 410
 411 -(NSImage*)SetImageColor:(NSImage*)image color:(int)c{
 412     NSImage *maskBlue, *maskRed, *maskYellow;
 413
 414     maskBlue = [NSImage imageNamed:@"ハイライト（青）"];
 415     maskRed = [NSImage imageNamed:@"ハイライト（赤）"];
 416     maskYellow = [NSImage imageNamed:@"ハイライト（黄）"];
 417
 418     NSImage *img = [NSImage alloc];
 419     img = [image copy];
 420
 421     if(c == 0){
 422         [img lockFocus];
 423         //[image drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, maskBlue.size.width, maskBlue.size.height) operation:NSCompositeClear fraction:1.0];
 424
 425         [maskBlue drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, maskBlue.size.width, maskBlue.size.height) operation:NSCompositeXOR fraction:1.0];
 426
 427         [maskBlue drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, maskBlue.size.width, maskBlue.size.height) operation:NSCompositeXOR fraction:1.0];
 428
 429         [img drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, image.size.width, image.size.height) operation:NSCompositeSourceOver fraction:0.6];
 430
 431         [img unlockFocus];
 432
 433     }
 434
 435     if(c == 1){
 436         [img lockFocus];
 437
 438         [maskYellow drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, maskBlue.size.width, maskBlue.size.height) operation:NSCompositeXOR fraction:1.0];
 439
 440         [maskYellow drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, maskBlue.size.width, maskBlue.size.height) operation:NSCompositeXOR fraction:1.0];
 441
 442         [img drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, image.size.width, image.size.height) operation:NSCompositeSourceOver fraction:0.6];
 443
 444         [img unlockFocus];
 445     }
 446
 447     if(c == 2){
 448         [img lockFocus];
 449
 450         [maskRed drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, maskBlue.size.width, maskBlue.size.height) operation:NSCompositeXOR fraction:1.0];
 451
 452         [maskRed drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, maskBlue.size.width, maskBlue.size.height) operation:NSCompositeXOR fraction:1.0];
 453
 454         [img drawInRect:NSMakeRect(0, 0, image.size.width, image.size.height) fromRect:NSMakeRect(0, 0, image.size.width, image.size.height) operation:NSCompositeSourceOver fraction:0.6];
 455
 456         [img unlockFocus];
 457     }
 458
 459     return img;
 460 }
 461
 462 -(NSImage*)LoadImage:(NSString*)name{
 463     NSImage *image = [NSImage imageNamed:name];
 464     if(image == nil) return nil;
 465     //[image setFlipped:[self isFlipped]];
 466
 467     return image;
 468 }
 469
 470 -(void)DrawImage:(NSImage*)image x:(float)x y:(float)y cx:(int)cx cy:(int)cy f:(float)frac{
 471     NSRect frRect;
 472     frRect.size.height = image.size.height;
 473     frRect.size.width = image.size.width;
 474
 475     frRect.origin.x = 0;
 476     frRect.origin.y = 0;
 477
 478     NSRect drRect;
 479     drRect.origin.x = x;
 480     drRect.origin.y = y;
 481     drRect.size.height = 32;
 482     drRect.size.width = 32;
 483
 484     [image drawInRect:drRect fromRect:frRect operation:NSCompositeSourceOver fraction:frac respectFlipped:YES hints:nil];
 485
 486 }
 487
 488 -(void)mouseDown:(NSEvent *)theEvent{
 489
 490     if(cpuAtkExtendFlag3 || cpuOMFGmoveATKfixFlag) return;
 491
 492     if(!battleBegin) return;
 493
 494     if(setBattleModeFlag) return;
 495
 496     if(endGameCondition) return;
 497
 498     if(waitSwtichFlag) return;
 499
 500     if(messageDialog){
 501
 502
 503         if(msgCnt >= msgMax){
 504             msgLvl++;
 505             msgCnt = 0;
 506             messageEndFlag = true;
 507         }else{
 508             msgCnt = msgMax-1;
 509         }
 510
 511
 512         return;
 513     }
 514
 515     pussyLoopFlag = true;
 516
 517     if(coolTime)
 518         return;
 519
 520     if(cpuAImodeflag)
 521         return;
 522
 523     if(P[1].type == 1){
 524
 525         U = UTop;
 526         while (U) {
 527             if(unitBreak->team == 2){
 528                 U = UTop;
 529                 return;
 530             }
 531             U = U->next;
 532         }
 533         U = UTop;
 534     }
 535
 536     drugPoint = [self convertPoint:[theEvent locationInWindow] fromView:nil];
 537
 538     possionX = (int)drugPoint.x/32+1;
 539     possionY = (int)drugPoint.y/32+1;
 540
 541     menuDisplayFlag = false;
 542
 543     U = UTop;
 544
 545     if(attackExtentFlag2 && g_attackRangeExtent[possionX][possionY] > 0){
 546         attackExtentFlag2 = false;
 547         attackExtentFlag = false;
 548         attackFlag = false;
 549         extentBattleFlag = true;
 550
 551         for (int i = 0;i < 255;i++) {
 552             DUN[i] = -1;
 553         }
 554
 555         int Unum = 0;
 556
 557
 558         while (U) {
 559             Unum++;
 560             U = U->next;
 561         }U = UTop;
 562
 563         while(U->number != AUN[1]){
 564             U = U->next;
 565         }
 566         UNIT *AUNU = U;
 567
 568         U = UTop;
 569         int z = 0;
 570         static bool okflag = true;
 571         while(U){
 572             for (int i = 0;i < 1002;i++) {
 573                 for (int k = 0;k < 1002;k++) {
 574                     objeR[i][k] = 0;
 575                 }
 576             }
 577             if(U->chipNumberL < 0){
 578                 [self checkAttackRangeExtent:possionY startY:possionX leftPow:AUNU->C.A->extent+1 pieceType:1 aMap:g_attackRangeExtent aPiece:&AUNU->C];
 579             }else {
 580                 [self checkAttackRangeExtent:possionY startY:possionX leftPow:AUNU->C.A->extent+1 pieceType:1 aMap:g_attackRangeExtent aPiece:&AUNU->C];
 581             }
 582
 583             int Cnum = 0;
 584
 585             for(int bx=1;bx<=chipWidth;bx++){
 586                 for(int by=1;by<=chipHeight;by++){
 587                     if(g_attackRangeExtent[bx][by] != 999 && g_attackRangeExtent[bx][by] > 0){
 588
 589                         if(g_attackRangeExtent[U->x][U->y] > 0 && attackExceptNumber != U-> number){
 590                             Cnum++;
 591                             if(Unum < Cnum) goto lolzOMFG;
 592
 593
 594
 595
 596
 597                             if(UP)
 598                             {
 599                                 if(!UPT){
 600                                     UPT = UP;
 601                                 }
 602
 603                                 UP = UPT;
 604                                 while (UP) {
 605                                     if(UP->x == U->x && UP->y == U->y){
 606
 607                                         break;
 608                                     }else{
 609                                         okflag = true;
 610                                     }
 611
 612                                     UP = UP->next;
 613                                 }
 614
 615                             }
 616                             UP = UPT;
 617
 618                             if(!UP) UP = calloc(1, sizeof(UNITPOINT));
 619                             else if(UP){
 620                                 while(UP->next) UP = UP->next;
 621                             }
 622                             if(okflag){
 623                                 z++;
 624                                 UP->x = U->x;
 625                                 UP->y = U->y;
 626                                 UP->next = calloc(1, sizeof(UNITPOINT));
 627                                 okflag = false;
 628                                 DUN[z] = U->number;
 629
 630                             }
 631                         }
 632
 633                     }
 634                 }
 635             }
 636
 637         lolzOMFG:
 638             UP = NULL;
 639             UPT = NULL;
 640
 641             U = U->next;
 642         }U = UTop;
 643         okflag = true;
 644         //NSLog(@"%d", DUN[0]);
 645         return;
 646     }else if(attackExtentFlag2){
 647         attackExtentFlag2 = false;
 648         attackExtentFlag = false;
 649         attackFlag = false;
 650         extentBattleFlag = false;
 651     }
 652
 653
 654     if(attackFlag && g_attackRange[possionX][possionY] <= 0){
 655         dcRdy2 = false;
 656         attackExtentFlag2 = false;
 657         attackExtentFlag = false;
 658         attackFlag = false;
 659     }
 660
 661     if(attackFlag && g_attackRange[possionX][possionY] > 0){
 662         if(atkExtentFlag){
 663
 664             dcRdy2 = true;
 665             attackExtentFlag2 = true;
 666             attackExtentFlag = true;
 667             attackFlag = false;
 668         }else if(unitNum[possionX][possionY] >= 0){
 669             attackFlag = false;
 670             battleWindowFlag = true;
 671
 672             U = UTop;
 673             while (AUN[1] != U->number) {
 674                 U = U->next;
 675             }
 676             ATTACK *aTop = U->C.A;
 677             ATTACK *aTop2 = U->CL.A;
 678             if(U->chipNumberL < 0){
 679                 for(int i = 0;i < crCAL;i++){
 680                     U->C.A = U->C.A->next;
 681                 }
 682             }else{
 683                 for(int i = 0;i < crCAL;i++){
 684                     U->CL.A = U->CL.A->next;
 685                 }
 686             }
 687
 688             if(U->chipNumberL < 0)
 689                 U->atkRange = U->C.A->rangeB - g_attackRange[possionX][possionY] + 1;
 690             else U->atkRange = U->CL.A->rangeB - g_attackRange[possionX][possionY] + 1;
 691
 692             U->atkRange = U->atkRange;
 693             U->C.A = aTop;
 694             U->CL.A = aTop2;
 695
 696             U = UTop;
 697             while (!(U->x == possionX && U->y == possionY) && U) {
 698                 U = U->next;
 699             }
 700             DUN[1] = U->number;
 701             U = UTop;
 702
 703             wtAttackedFlag = true;
 704             return;
 705         }
 706     }U = UTop;
 707
 708     if(summonFlag && g_summonRange[possionX][possionY] > 0 && unitNum[possionX][possionY] < 0){
 709
 710         summonRdyFlag = true;
 711         summonFlag = false;
 712
 713     }
 714
 715
 716
 717     if(unitNum[possionX][possionY] >= 0){
 718
 719         if(!attackFlag && !attackExtentFlag2) atkExtentFlag = false;
 720
 721         if(atkExtentFlag) return;
 722
 723         moveFlag = false;
 724         attackFlag = false;
 725         stanbyFlag = false;
 726         menuDisplayFlag = true;
 727         unitMoveEndFlag = false;
 728         g_cursol_x = 1+(int)drugPoint.y/32;
 729         g_cursol_y = 1+(int)drugPoint.x/32;
 730         currentPosX = g_cursol_y*32;
 731         currentPosY = g_cursol_x*32;
 732
 733         UCselected = UC[unitNum[possionX][possionY]];
 734         LCselected = LC[loadNum[possionX][possionY]];
 735
 736         U = UTop;
 737         while (U) {
 738             if(U->x == possionX && U->y == possionY) break;
 739             U = U->next;
 740         }
 741
 742
 743         //NSLog(@"%@, %@", U->C.name, U->C.A->name);
 744         if(U){
 745             AUN[1] = U->number;
 746             Uselected = U;
 747         }else{
 748             ///////////////////////////バグフィクス//////////////////////////
 749
 750             unitNum[possionX][possionY] = -1;
 751             loadNum[possionX][possionY] = -1;
 752             U = UTop;
 753             return;
 754         }
 755
 756         if(U->chipNumber >= 0) [self LookupMovableRange:possionY startY:possionX aPiece:&UC[unitNum[possionX][possionY]] turnSide:YES];
 757         if(U->chipNumberL >= 0) [self LookupMovableRange2:possionY startY:possionX aPiece:&LC[loadNum[possionX][possionY]] turnSide:YES];
 758
 759         U = UTop;
 760
 761         //return;
 762     }
 763
 764     if(buildNum[possionX][possionY] >= 0 && unitNum[possionX][possionY] < 0 && !moveFlag){
 765         //NSLog(@"くりとりすとおちんちん");
 766         B = BTop;
 767         while (B) {
 768             if(B->x == possionX && B->y == possionY){
 769                 researchTeam = -1;
 770                 if(B->team == 0){
 771                     researchTeam = 0;
 772                     break;
 773                 }
 774                 if(B->team == 2){
 775                     researchTeam = 2;
 776                     break;
 777                 }
 778             }
 779             B = B->next;
 780         }B = BTop;
 781
 782         if (researchTeam < 0) {
 783
 784         }else{
 785             stanbyFlag = false;
 786             buildSelectedFlag = true;
 787         }
 788     }
 789
 790     if(moveFlag && g_selectRange[possionX][possionY] > 0){
 791         g_target_y = possionX;
 792         g_target_x = possionY;
 793
 794         [self searchRoute];
 795
 796         for(int i = 0;i<=chipWidth;i++){
 797             for(int j = 0;j<=chipHeight;j++){
 798                 g_map[j][i] = chipNum[j][i];
 799                 g_selectRange[j][i] = 0;
 800             }
 801         }
 802         moveFlag = false;
 803         stanbyFlag = true;
 804         wtPx = possionX;
 805         wtPy = possionY;
 806         wtMovedFlag = true;
 807         B = BTop;
 808         while (B) {
 809             if(B->x == possionX && B->y == possionY && B->C.capture){
 810                 buildCaptureFlag = true;
 811             }
 812             B = B->next;
 813         }B = BTop;
 814
 815     }
 816
 817     summonFlag = false;
 818
 819     pushStanbyFlag = false;
 820 }
 821
 822
 823
 824
 825 //-----------------------------------------------------------LookupMovableRange
 826 //
 827 // 与えられた位置からの移動可能範囲をg_range配列内に収める
 828 //
 829 //-----------------------------------------------------------------------------
 830 -(void)LookupMovableRange:(int)startX startY:(int)startY aPiece:(UNITCHIP*)aPiece turnSide:(BOOL)turnSide
 831 {
 832     if(!aPiece->nameID) return;
 833
 834     for(int i = 0;i<=chipWidth;i++){
 835         for(int j = 0;j<=chipHeight;j++){
 836             g_map[j][i] = -1;
 837             g_selectRange[j][i] = 999;
 838         }
 839     }
 840
 841     for(int i = 1;i<=chipWidth;i++){
 842         for(int j = 1;j<=chipHeight;j++){
 843             g_map[j][i] = chipNum[j][i];
 844             g_selectRange[j][i] = 0;
 845         }
 846     }
 847
 848     //0 リク　1宙 2海 3空
 849     //0 草原 1荒地
 850     enum{
 851         MOVETYPE_RIKU,
 852         MOVETYPE_CHU,
 853         MOVETYPE_UMI,
 854         MOVETYPE_SORA,
 855     };
 856     for(int chipType = 0;chipType < 128;chipType++){
 857         g_moveCost[MOVETYPE_RIKU][chipType] = MC[chipType].riku;
 858         g_moveCost[MOVETYPE_CHU][chipType] = MC[chipType].chu;
 859         g_moveCost[MOVETYPE_UMI][chipType] = MC[chipType].umi;
 860         g_moveCost[MOVETYPE_SORA][chipType] = MC[chipType].sora;
 861     }
 862
 863     g_selectRange[startY][startX] = aPiece->S_C.MOV+1;
 864     //[self excludePiece:turnSide fillInt:99];
 865     // 敵方のコマを迂回させるため、マップ移動最大値を詰め込む
 866     //[self excludePiece:turnSide fillInt:0];
 867     [self checkRange:startX startY:startY leftPow:aPiece->S_C.MOV+1 pieceType:aPiece->S_C.typeMOVE aMap:g_selectRange];
 868     //  [self excludePiece:turnSide fillInt:0];
 869     // 敵方のコマの位置を移動可能範囲から除外する
 870     //[self excludePiece:turnSide fillInt:0];
 871
 872
 873 }
 874
 875 -(void)LookupMovableRange2:(int)startX startY:(int)startY aPiece:(LOADCHIP*)aPiece turnSide:(BOOL)turnSide
 876 {
 877     if(!aPiece->nameID) return;
 878
 879     for(int i = 0;i<=chipWidth;i++){
 880         for(int j = 0;j<=chipHeight;j++){
 881             g_map[j][i] = -1;
 882             g_selectRange[j][i] = 999;
 883         }
 884     }
 885
 886     for(int i = 1;i<=chipWidth;i++){
 887         for(int j = 1;j<=chipHeight;j++){
 888             g_map[j][i] = chipNum[j][i];
 889             g_selectRange[j][i] = 0;
 890         }
 891     }
 892
 893     //0 リク　1宙 2海 3空
 894     //0 草原 1荒地
 895     enum{
 896         MOVETYPE_RIKU,
 897         MOVETYPE_CHU,
 898         MOVETYPE_UMI,
 899         MOVETYPE_SORA,
 900     };
 901     for(int chipType = 0;chipType < 128;chipType++){
 902         g_moveCost[MOVETYPE_RIKU][chipType] = MC[chipType].riku;
 903         g_moveCost[MOVETYPE_CHU][chipType] = MC[chipType].chu;
 904         g_moveCost[MOVETYPE_UMI][chipType] = MC[chipType].umi;
 905         g_moveCost[MOVETYPE_SORA][chipType] = MC[chipType].sora;
 906     }
 907
 908     g_selectRange[startY][startX] = aPiece->S_C.MOV+1;
 909     //[self excludePiece:turnSide fillInt:99];
 910     // 敵方のコマを迂回させるため、マップ移動最大値を詰め込む
 911     [self checkRange2:startX startY:startY leftPow:aPiece->S_C.MOV+1 pieceType:aPiece->S_C.typeMOVE aMap:g_selectRange];
 912     //[self excludePiece:turnSide fillInt:0];
 913     // 敵方のコマの位置を移動可能範囲から除外する
 914
 915 }
 916
 917 //-----------------------------------------------------------------excludePiece
 918 // 選択範囲からコマを除外する
 919 -(void)excludePiece:(BOOL)turnSide fillInt:(int)fillInt
 920 {
 921     UNIT *UN = U;
 922
 923
 924     U = UTop;
 925
 926     while(U){
 927         for(int x = 1;x <= chipWidth;x++){
 928             for(int y = 1;y <= chipHeight;y++){
 929                 if(g_selectRange[U->x][U->y] > 0 && U->x == y && U->y == x){
 930                     g_selectRange[U->x][U->y] = fillInt;
 931                 }
 932             }
 933         }
 934         U = U->next;
 935     }U = UN;
 936     g_selectRange[Uselected->x][Uselected->y] = 999;
 937
 938 }
 939
 940 //-------------------------------------------------------------------checkRange
 941 // 再帰法で移動可能範囲をチェックする
 942 // 配列の添え字と関数の引数が逆になっていることに要注意
 943 -(void)checkRange:(int)startX startY:(int)startY leftPow:(int)leftPow pieceType:(int)pieceType aMap:(int[1002][1002])aMap{
 944     int  i0;
 945
 946
 947     int chipTeam;
 948     if(Uselected) chipTeam = Uselected->team;
 949
 950     if(startX < 0) startX = 0;
 951     if(startY < 0) startY = 0;
 952
 953     aMap[startY][startX] = leftPow;// 残り移動力
 954
 955
 956     i0 = leftPow - g_moveCost[pieceType][g_map[startY-1][startX]];  // 上
 957
 958     if(unitNum[startY-1][startX] > -1 && unitTeam[startY-1][startX] != chipTeam){
 959         i0 = 0;
 960     }
 961     if( aMap[startY-1][startX] < i0 ){
 962         [self checkRange:startX startY:startY - 1 leftPow:i0 pieceType:pieceType aMap:aMap];
 963     }
 964
 965
 966     i0 = leftPow - g_moveCost[pieceType][g_map[startY+1][startX]];  // 下
 967     if(unitNum[startY+1][startX] > -1 && unitTeam[startY+1][startX] != chipTeam){
 968         i0 = 0;
 969     }
 970     if( aMap[startY+1][startX] < i0 ){
 971         [self checkRange:startX startY:startY + 1 leftPow:i0 pieceType:pieceType aMap:aMap];
 972     }
 973
 974
 975     i0 = leftPow - g_moveCost[pieceType][g_map[startY][startX-1]];  // 右
 976     if(unitNum[startY][startX-1] > -1 && unitTeam[startY][startX-1] != chipTeam){
 977         i0 = 0;
 978     }
 979     if( aMap[startY][startX-1] < i0 ){
 980         [self checkRange:startX - 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap];
 981     }
 982
 983
 984     i0 = leftPow - g_moveCost[pieceType][g_map[startY][startX+1]];  // 左
 985     if(unitNum[startY][startX+1] > -1 && unitTeam[startY][startX+1] != chipTeam){
 986         i0 = 0;
 987     }
 988     if( aMap[startY][startX+1] < i0 ){
 989         [self checkRange:startX + 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap];
 990     }
 991
 992 }
 993
 994 -(void)checkRange2:(int)startX startY:(int)startY leftPow:(int)leftPow pieceType:(int)pieceType aMap:(int[1002][1002])aMap{
 995     int  i0;
 996
 997
 998     int chipTeam;
 999     if(Uselected) chipTeam = Uselected->team;
1000
1001     if(startX < 0) startX = 0;
1002     if(startY < 0) startY = 0;
1003
1004     aMap[startY][startX] = leftPow;// 残り移動力
1005
1006
1007     i0 = leftPow - g_moveCost[pieceType][g_map[startY-1][startX]];  // 上
1008
1009     if(loadNum[startY-1][startX] > -1 && unitTeam[startY-1][startX] != chipTeam){
1010         i0 = 0;
1011     }
1012     if( aMap[startY-1][startX] < i0 ){
1013         [self checkRange:startX startY:startY - 1 leftPow:i0 pieceType:pieceType aMap:aMap];
1014     }
1015
1016
1017     i0 = leftPow - g_moveCost[pieceType][g_map[startY+1][startX]];  // 下
1018     if(loadNum[startY+1][startX] > -1 && unitTeam[startY+1][startX] != chipTeam){
1019         i0 = 0;
1020     }
1021     if( aMap[startY+1][startX] < i0 ){
1022         [self checkRange:startX startY:startY + 1 leftPow:i0 pieceType:pieceType aMap:aMap];
1023     }
1024
1025
1026     i0 = leftPow - g_moveCost[pieceType][g_map[startY][startX-1]];  // 右
1027     if(loadNum[startY][startX-1] > -1 && unitTeam[startY][startX-1] != chipTeam){
1028         i0 = 0;
1029     }
1030     if( aMap[startY][startX-1] < i0 ){
1031         [self checkRange:startX - 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap];
1032     }
1033
1034
1035     i0 = leftPow - g_moveCost[pieceType][g_map[startY][startX+1]];  // 左
1036     if(loadNum[startY][startX+1] > -1 && unitTeam[startY][startX+1] != chipTeam){
1037         i0 = 0;
1038     }
1039     if( aMap[startY][startX+1] < i0 ){
1040         [self checkRange:startX + 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap];
1041     }
1042
1043 }
1044
1045
1046 -(void)LookupSummonRange:(int)startX startY:(int)startY aPiece:(UNITCHIP*)aPiece turnSide:(BOOL)turnSide
1047 {
1048
1049     for(int i = 0;i<=chipWidth;i++){
1050         for(int j = 0;j<=chipHeight;j++){
1051             g_summonRange[j][i] = 999;
1052             g_summonRangeDelta[j][i] = 999;
1053         }
1054     }
1055
1056     for(int i = 1;i<=chipWidth;i++){
1057         for(int j = 1;j<=chipHeight;j++){
1058             g_summonRange[j][i] = 0;
1059             g_summonRangeDelta[j][i] = 0;
1060         }
1061     }
1062
1063     for(int chipType = 0;chipType < 1024;chipType++){
1064         g_attackCost[0][chipType] = 1;
1065     }
1066
1067     //0 リク　1宙 2海 3空
1068     //0 草原 1荒地
1069
1070     ATTACK *aTop = aPiece->A;
1071     for(int i = 0;i < crCAL;i++){
1072         aPiece->A = aPiece->A->next;
1073     }
1074
1075     g_summonRange[startY][startX] = 1;
1076     g_summonRangeDelta[startY][startX] = 0;
1077     //attackMaxNum = aPiece->A->rangeB+1;
1078
1079     //[self excludePiece:turnSide fillInt:99];
1080     // 敵方のコマを迂回させるため、マップ移動最大値を詰め込む
1081     [self checkSummonRange:startX startY:startY leftPow:2 pieceType:0 aMap:g_summonRange aPiece:aPiece];
1082     g_summonRange[startY][startX] = 0;
1083     g_summonRangeDelta[startY][startX] = 0;
1084
1085     for(int i = 0;i<=chipWidth;i++){
1086         for(int j = 0;j<=chipHeight;j++){
1087             if(g_summonRangeDelta[i][j] > 0) g_summonRange[i][j] = 0;
1088         }
1089     }
1090
1091     aPiece->A = aTop;
1092
1093     //[self excludePiece:turnSide fillInt:0];
1094     // 敵方のコマの位置を移動可能範囲から除外する
1095
1096 }
1097
1098 -(void)checkSummonRange:(int)startX startY:(int)startY leftPow:(int)leftPow pieceType:(int)pieceType aMap:(int[][1002])aMap aPiece:(UNITCHIP*)aPiece{
1099     int  i0;
1100
1101     if(startX < 0) startX = 0;
1102     if(startY < 0) startY = 0;
1103
1104     aMap[startY][startX] = leftPow;    // 残り射程の長さ
1105
1106     i0 = leftPow - 1;  // 上
1107     if( aMap[startY-1][startX] < i0 ){
1108         [self checkSummonRange:startX startY:startY - 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1109     }
1110
1111     i0 = leftPow - 1;  // 下
1112     if( aMap[startY+1][startX] < i0 ){
1113         [self checkSummonRange:startX startY:startY + 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1114     }
1115
1116     i0 = leftPow - 1;  // 右
1117     if( aMap[startY][startX-1] < i0 ){
1118         [self checkSummonRange:startX - 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1119     }
1120
1121     i0 = leftPow - 1;  // 左
1122     if( aMap[startY][startX+1] < i0 ){
1123         [self checkSummonRange:startX + 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1124     }
1125
1126 }
1127
1128
1129 -(void)LookupAttackRange:(int)startX startY:(int)startY aPiece:(UNITCHIP*)aPiece turnSide:(BOOL)turnSide
1130 {
1131
1132     for(int i = 0;i<=chipWidth;i++){
1133         for(int j = 0;j<=chipHeight;j++){
1134             g_attackRange[j][i] = 999;
1135             g_attackRangeDelta[j][i] = 999;
1136         }
1137     }
1138
1139     for(int i = 1;i<=chipWidth;i++){
1140         for(int j = 1;j<=chipHeight;j++){
1141             g_attackRange[j][i] = 0;
1142             g_attackRangeDelta[j][i] = 0;
1143         }
1144     }
1145
1146     for(int chipType = 0;chipType < 1024;chipType++){
1147         g_attackCost[0][chipType] = 1;
1148     }
1149
1150     //0 リク　1宙 2海 3空
1151     //0 草原 1荒地
1152     enum{
1153         MOVETYPE_RIKU,
1154         MOVETYPE_CHU,
1155         MOVETYPE_UMI,
1156         MOVETYPE_SORA,
1157     };
1158
1159     ATTACK *aTop = aPiece->A;
1160     for(int i = 0;i < crCAL;i++){
1161         aPiece->A = aPiece->A->next;
1162     }
1163
1164     g_attackRange[startY][startX] = aPiece->A->rangeB;
1165     g_attackRangeDelta[startY][startX] = aPiece->A->rangeA;
1166     attackMaxNum = aPiece->A->rangeB+1;
1167
1168     //[self excludePiece:turnSide fillInt:99];
1169     // 敵方のコマを迂回させるため、マップ移動最大値を詰め込む
1170     if(aPiece->A->rangeB >= 1 && aPiece->A->rangeA >= 0){
1171         [self checkAttackRange:startX startY:startY leftPow:aPiece->A->rangeB+1 pieceType:0 aMap:g_attackRange aPiece:aPiece];
1172         [self checkAttackRange:startX startY:startY leftPow:aPiece->A->rangeA pieceType:1 aMap:g_attackRangeDelta aPiece:aPiece];
1173         g_attackRange[startY][startX] = 0;
1174         g_attackRangeDelta[startY][startX] = 0;
1175
1176         for(int i = 0;i<=chipWidth;i++){
1177             for(int j = 0;j<=chipHeight;j++){
1178                 if(g_attackRangeDelta[i][j] > 0) g_attackRange[i][j] = 0;
1179             }
1180         }
1181
1182         if(aPiece->A->rangeA == 0) g_attackRange[startY][startX] = 10;
1183
1184     }else{
1185         [self checkAttackRange:startX startY:startY leftPow:aPiece->A->rangeA+1 pieceType:1 aMap:g_attackRange aPiece:aPiece];
1186         g_attackRange[startY][startX] = 0;
1187         if(aPiece->A->rangeA == 0) g_attackRange[startY][startX] = 10;
1188     }
1189
1190     aPiece->A = aTop;
1191
1192     //[self excludePiece:turnSide fillInt:0];
1193     // 敵方のコマの位置を移動可能範囲から除外する
1194
1195 }
1196
1197 -(void)LookupAttackRange2:(int)startX startY:(int)startY aPiece:(LOADCHIP*)aPiece turnSide:(BOOL)turnSide
1198 {
1199
1200     for(int i = 0;i<=chipWidth;i++){
1201         for(int j = 0;j<=chipHeight;j++){
1202             g_attackRange[j][i] = 999;
1203             g_attackRangeDelta[j][i] = 999;
1204         }
1205     }
1206
1207     for(int i = 1;i<=chipWidth;i++){
1208         for(int j = 1;j<=chipHeight;j++){
1209             g_attackRange[j][i] = 0;
1210             g_attackRangeDelta[j][i] = 0;
1211         }
1212     }
1213
1214     for(int chipType = 0;chipType < 1024;chipType++){
1215         g_attackCost[0][chipType] = 1;
1216     }
1217
1218     //0 リク　1宙 2海 3空
1219     //0 草原 1荒地
1220     enum{
1221         MOVETYPE_RIKU,
1222         MOVETYPE_CHU,
1223         MOVETYPE_UMI,
1224         MOVETYPE_SORA,
1225     };
1226
1227     ATTACK *aTop = aPiece->A;
1228     for(int i = 0;i < crCAL;i++){
1229         aPiece->A = aPiece->A->next;
1230     }
1231
1232     g_attackRange[startY][startX] = aPiece->A->rangeB;
1233     g_attackRangeDelta[startY][startX] = aPiece->A->rangeA;
1234     attackMaxNum = aPiece->A->rangeB+1;
1235
1236     //[self excludePiece:turnSide fillInt:99];
1237     // 敵方のコマを迂回させるため、マップ移動最大値を詰め込む
1238     if(aPiece->A->rangeB > 1 && aPiece->A->rangeA >= 0){
1239         [self checkAttackRange2:startX startY:startY leftPow:aPiece->A->rangeB+1 pieceType:0 aMap:g_attackRange aPiece:aPiece];
1240         [self checkAttackRange2:startX startY:startY leftPow:aPiece->A->rangeA pieceType:1 aMap:g_attackRangeDelta aPiece:aPiece];
1241         g_attackRange[startY][startX] = 0;
1242         g_attackRangeDelta[startY][startX] = 0;
1243
1244         for(int i = 0;i<=chipWidth;i++){
1245             for(int j = 0;j<=chipHeight;j++){
1246                 if(g_attackRangeDelta[i][j] > 0) g_attackRange[i][j] = 0;
1247             }
1248         }
1249
1250         if(aPiece->A->rangeA == 0) g_attackRange[startY][startX] = 10;
1251
1252     }else{
1253         [self checkAttackRange2:startX startY:startY leftPow:aPiece->A->rangeA+1 pieceType:1 aMap:g_attackRange aPiece:aPiece];
1254         g_attackRange[startY][startX] = 0;
1255         if(aPiece->A->rangeA == 0) g_attackRange[startY][startX] = 10;
1256     }
1257
1258     aPiece->A = aTop;
1259
1260     //[self excludePiece:turnSide fillInt:0];
1261     // 敵方のコマの位置を移動可能範囲から除外する
1262
1263 }
1264
1265 -(void)checkAttackRange:(int)startX startY:(int)startY leftPow:(int)leftPow pieceType:(int)pieceType aMap:(int[][1002])aMap aPiece:(UNITCHIP*)aPiece{
1266     int  i0;
1267
1268     int chipTeam;
1269     if(Uselected) chipTeam = Uselected->team;
1270
1271     if(startX < 0) startX = 0;
1272     if(startY < 0) startY = 0;
1273
1274     aMap[startY][startX] = leftPow;    // 残り射程の長さ
1275     i0 = leftPow - 1;  // 上
1276     /*if(unitTeam[startY][startX] == chipTeam){
1277      aMap[startY][startX] = 0;
1278      }*/
1279
1280     if( aMap[startY-1][startX] < i0 ){
1281         [self checkAttackRange:startX startY:startY - 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1282     }
1283
1284     i0 = leftPow - 1;  // 下
1285     if( aMap[startY+1][startX] < i0 ){
1286         [self checkAttackRange:startX startY:startY + 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1287     }
1288
1289     i0 = leftPow - 1;  // 右
1290     if( aMap[startY][startX-1] < i0 ){
1291         [self checkAttackRange:startX - 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1292     }
1293
1294     i0 = leftPow - 1;  // 左
1295     if( aMap[startY][startX+1] < i0 ){
1296         [self checkAttackRange:startX + 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1297     }
1298
1299 }
1300
1301 -(void)checkAttackRange2:(int)startX startY:(int)startY leftPow:(int)leftPow pieceType:(int)pieceType aMap:(int[][1002])aMap aPiece:(LOADCHIP*)aPiece{
1302     int  i0;
1303
1304     if(startX < 0) startX = 0;
1305     if(startY < 0) startY = 0;
1306
1307     aMap[startY][startX] = leftPow;    // 残り射程の長さ
1308
1309     i0 = leftPow - 1;  // 上
1310     if( aMap[startY-1][startX] < i0 ){
1311         [self checkAttackRange2:startX startY:startY - 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1312     }
1313
1314     i0 = leftPow - 1;  // 下
1315     if( aMap[startY+1][startX] < i0 ){
1316         [self checkAttackRange2:startX startY:startY + 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1317     }
1318
1319     i0 = leftPow - 1;  // 右
1320     if( aMap[startY][startX-1] < i0 ){
1321         [self checkAttackRange2:startX - 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1322     }
1323
1324     i0 = leftPow - 1;  // 左
1325     if( aMap[startY][startX+1] < i0 ){
1326         [self checkAttackRange2:startX + 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1327     }
1328
1329 }
1330
1331
1332 -(void)checkRangeAttack:(int)startX startY:(int)startY leftPow:(int)leftPow pieceType:(int)pieceType aMap:(int[][1002])aMap aPiece:(UNITCHIP*)aPiece i:(int)i{
1333
1334     int  i0;
1335
1336     if(startX < 0) startX = 0;
1337     if(startY < 0) startY = 0;
1338
1339     aMap[startY][startX] = leftPow;    // 残り射程の長さ
1340
1341     i0 = leftPow - 1;  // 上
1342     if( aMap[startY-1][startX] < i0 ){
1343         [self checkRangeAttack:startX startY:startY - 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece i:i];
1344     }
1345
1346     i0 = leftPow - 1;  // 下
1347     if( aMap[startY+1][startX] < i0 ){
1348         [self checkRangeAttack:startX startY:startY + 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece i:i];
1349     }
1350
1351     i0 = leftPow - 1;  // 右
1352     if( aMap[startY][startX-1] < i0 ){
1353         [self checkRangeAttack:startX - 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece i:i];
1354     }
1355
1356     i0 = leftPow - 1;  // 左
1357     if( aMap[startY][startX+1] < i0 ){
1358         [self checkRangeAttack:startX + 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece i:i];
1359     }
1360 }
1361
1362
1363
1364 -(void)LookupAttackRangeExtent:(int)startX startY:(int)startY aPiece:(UNITCHIP*)aPiece turnSide:(BOOL)turnSide
1365 {
1366
1367     for(int i = 0;i<=chipWidth;i++){
1368         for(int j = 0;j<=chipHeight;j++){
1369             g_attackRangeExtent[j][i] = 999;
1370         }
1371     }
1372
1373     for(int i = 1;i<=chipWidth;i++){
1374         for(int j = 1;j<=chipHeight;j++){
1375             g_attackRangeExtent[j][i] = 0;
1376         }
1377     }
1378
1379     for(int chipType = 0;chipType < 1024;chipType++){
1380         g_attackCost[0][chipType] = 1;
1381     }
1382
1383     //0 リク　1宙 2海 3空
1384     //0 草原 1荒地
1385     enum{
1386         MOVETYPE_RIKU,
1387         MOVETYPE_CHU,
1388         MOVETYPE_UMI,
1389         MOVETYPE_SORA,
1390     };
1391
1392     ATTACK *aTop = aPiece->A;
1393     for(int i = 0;i < crCAL;i++){
1394         aPiece->A = aPiece->A->next;
1395     }
1396
1397     g_attackRangeExtent[startY][startX] = aPiece->A->extent;
1398     attackMaxNum = aPiece->A->extent;
1399
1400     //[self excludePiece:turnSide fillInt:99];
1401     // 敵方のコマを迂回させるため、マップ移動最大値を詰め込む
1402
1403
1404     [self checkAttackRangeExtent:startX startY:startY leftPow:aPiece->A->extent+1 pieceType:1 aMap:g_attackRangeExtent aPiece:aPiece];
1405
1406     aPiece->A = aTop;
1407
1408     //[self excludePiece:turnSide fillInt:0];
1409     // 敵方のコマの位置を移動可能範囲から除外する
1410
1411 }
1412
1413 -(void)checkAttackRangeExtent:(int)startX startY:(int)startY leftPow:(int)leftPow pieceType:(int)pieceType aMap:(int[][1002])aMap aPiece:(UNITCHIP*)aPiece{
1414     int  i0;
1415
1416     int chipTeam;
1417     if(Uselected) chipTeam = Uselected->team;
1418
1419     if(startX < 0) startX = 0;
1420     if(startY < 0) startY = 0;
1421
1422     aMap[startY][startX] = leftPow;    // 残り射程の長さ
1423     i0 = leftPow - 1;  // 上
1424     /*if(unitTeam[startY][startX] == chipTeam){
1425      aMap[startY][startX] = 0;
1426      }*/
1427
1428     if( aMap[startY-1][startX] < i0 ){
1429         [self checkAttackRangeExtent:startX startY:startY - 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1430     }
1431
1432     i0 = leftPow - 1;  // 下
1433     if( aMap[startY+1][startX] < i0 ){
1434         [self checkAttackRangeExtent:startX startY:startY + 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1435     }
1436
1437     i0 = leftPow - 1;  // 右
1438     if( aMap[startY][startX-1] < i0 ){
1439         [self checkAttackRangeExtent:startX - 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1440     }
1441
1442     i0 = leftPow - 1;  // 左
1443     if( aMap[startY][startX+1] < i0 ){
1444         [self checkAttackRangeExtent:startX + 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1445     }
1446
1447 }
1448
1449 -(void)LookupAttackRangeExtent2:(int)startX startY:(int)startY aPiece:(LOADCHIP*)aPiece turnSide:(BOOL)turnSide
1450 {
1451
1452     for(int i = 0;i<=chipWidth;i++){
1453         for(int j = 0;j<=chipHeight;j++){
1454             g_attackRangeExtent[j][i] = 999;
1455         }
1456     }
1457
1458     for(int i = 1;i<=chipWidth;i++){
1459         for(int j = 1;j<=chipHeight;j++){
1460             g_attackRangeExtent[j][i] = 0;
1461         }
1462     }
1463
1464     for(int chipType = 0;chipType < 1024;chipType++){
1465         g_attackCost[0][chipType] = 1;
1466     }
1467
1468     //0 リク　1宙 2海 3空
1469     //0 草原 1荒地
1470     enum{
1471         MOVETYPE_RIKU,
1472         MOVETYPE_CHU,
1473         MOVETYPE_UMI,
1474         MOVETYPE_SORA,
1475     };
1476
1477     ATTACK *aTop = aPiece->A;
1478     for(int i = 0;i < crCAL;i++){
1479         aPiece->A = aPiece->A->next;
1480     }
1481
1482     g_attackRangeExtent[startY][startX] = aPiece->A->extent;
1483     attackMaxNum = aPiece->A->extent;
1484
1485     //[self excludePiece:turnSide fillInt:99];
1486     // 敵方のコマを迂回させるため、マップ移動最大値を詰め込む
1487
1488
1489     [self checkAttackRangeExtent2:startX startY:startY leftPow:aPiece->A->extent pieceType:1 aMap:g_attackRange aPiece:aPiece];
1490     g_attackRangeExtent[startY][startX] = 0;
1491
1492     aPiece->A = aTop;
1493
1494     //[self excludePiece:turnSide fillInt:0];
1495     // 敵方のコマの位置を移動可能範囲から除外する
1496
1497 }
1498
1499 -(void)checkAttackRangeExtent2:(int)startX startY:(int)startY leftPow:(int)leftPow pieceType:(int)pieceType aMap:(int[][1002])aMap aPiece:(LOADCHIP*)aPiece{
1500     int  i0;
1501
1502     int chipTeam;
1503     if(Uselected) chipTeam = Uselected->team;
1504
1505     if(startX < 0) startX = 0;
1506     if(startY < 0) startY = 0;
1507
1508     aMap[startY][startX] = leftPow;    // 残り射程の長さ
1509     i0 = leftPow - 1;  // 上
1510     /*if(unitTeam[startY][startX] == chipTeam){
1511      aMap[startY][startX] = 0;
1512      }*/
1513
1514     if( aMap[startY-1][startX] < i0 ){
1515         [self checkAttackRangeExtent2:startX startY:startY - 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1516     }
1517
1518     i0 = leftPow - 1;  // 下
1519     if( aMap[startY+1][startX] < i0 ){
1520         [self checkAttackRangeExtent2:startX startY:startY + 1 leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1521     }
1522
1523     i0 = leftPow - 1;  // 右
1524     if( aMap[startY][startX-1] < i0 ){
1525         [self checkAttackRangeExtent2:startX - 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1526     }
1527
1528     i0 = leftPow - 1;  // 左
1529     if( aMap[startY][startX+1] < i0 ){
1530         [self checkAttackRangeExtent2:startX + 1 startY:startY leftPow:i0 pieceType:pieceType aMap:aMap aPiece:aPiece];
1531     }
1532
1533 }
1534
1535 -(void)makeEnemyAI{
1536
1537     for(int g = 0;g <= chipWidth;g++){
1538         for(int h = 0; h <= chipHeight;h++){
1539             g_attackRangeBeta [h][g] = 0;
1540         }
1541     }
1542     [self LookupMovableRange:unitBreak->y startY:unitBreak->x aPiece:&unitBreak->C turnSide:YES];
1543
1544
1545     for (int x = 0; x <= chipWidth;x++) {
1546         for(int y = 0; y <= chipHeight;y++){
1547
1548             if(g_selectRange[y][x] > 0 && g_selectRange[y][x] != 999 ){
1549
1550                 ATTACK *UAT;
1551                 UA = unitBreak->C.A;
1552                 UAT = unitBreak->C.A;
1553
1554
1555
1556                 if(!UAT) return;
1557                 crCAL1 = 0;
1558                 while (unitBreak->C.A) {
1559                     double mpcost = floor(unitBreak->C.A->MP + unitBreak->C.A->pMP*unitBreak->C.S_M.MP/100 + 0.5);
1560
1561                     double vigcost = unitBreak->C.A->vigor;
1562
1563                     if(UA->rangeB <= unitBreak->C.A->rangeB && mpcost <= unitBreak->C.S_C.MP && vigcost <= unitBreak->C.S_C.vigor){
1564
1565                         UA = unitBreak->C.A;
1566                     }
1567
1568                     unitBreak->C.A = unitBreak->C.A->next;
1569                 }unitBreak->C.A = UAT;
1570
1571
1572
1573                 if(UA)
1574                     if(UA->rangeB <= 0) {
1575                         UA = unitBreak->C.A;
1576                         UA->rangeB = 1;
1577                         crCAL1 = 0;
1578                     }
1579
1580                 if(UA->extent > 0){
1581                     cpuAtkExtendFlag = true;
1582                 }
1583
1584                 while (unitBreak->C.A && UA != unitBreak->C.A) {
1585                     unitBreak->C.A = unitBreak->C.A->next;
1586                     crCAL1++;
1587                 }unitBreak->C.A = UAT;
1588
1589                 unitBreak->atkRange = UA->rangeB;
1590
1591                 for(int g = 0;g <= chipWidth;g++){
1592                     for(int h = 0; h <= chipHeight;h++){
1593                         g_attackRangeAlpha [h][g] = 0;
1594                     }
1595                 }
1596
1597                 [self checkAttackRange:x startY:y leftPow:UA->rangeB+1 pieceType:unitBreak->C.S_C.typeMONS aMap:g_attackRangeAlpha aPiece:&unitBreak->C];
1598
1599                 for (int j = 0; j <= chipWidth;j++) {
1600                     for(int k = 0;k <= chipHeight;k++){
1601                         if(g_attackRangeBeta[k][j] < g_attackRangeAlpha[k][j]) g_attackRangeBeta[k][j] = g_attackRangeAlpha[k][j];
1602                     }
1603                 }
1604             }
1605         }
1606     }
1607
1608 }
1609
1610
1611 //-------------------------------------------------------------------searchRute
1612 -(void)searchRoute{
1613     int i0;
1614
1615     // ルートテンポラリとルートバッファの初期化
1616     for( i0 = 0; i0 < 2100; i0++ )
1617     { g_tmpRoute[i0][0] = 0; g_tmpRoute[i0][1] = 0; g_moveRoute[i0][0] = 0;
1618         g_moveRoute[i0][1] = 0; }
1619
1620     for(int i = 0;i < 2100;i++){// テンポラリマップのゼロリセット
1621         for(int j = 0;j< 2100;j++){
1622             g_tmpMap[j][i] = 0;
1623         }
1624     }
1625     g_stackPointer = 0;              // スタックポインタ初期化
1626     g_shallowDepth = 1002;   //「最も浅いスタック」を持たせるために、// 最も深い値を与えておく
1627
1628     [self checkRoute:g_cursol_x startY:g_cursol_y];
1629
1630     // 経路をテンポラリマップに書き込む
1631     i0 = 0;
1632     g_moveCount = 0;
1633     while( i0 < g_shallowDepth)
1634     {
1635         g_tmpMap[g_moveRoute[i0][1]][g_moveRoute[i0][0]] = 1;
1636
1637         i0++;
1638     }
1639 }
1640
1641 //-------------------------------------------------------------------checkRout
1642 -(void)checkRoute:(int)startX startY:(int)startY{
1643     int i0 = 0;
1644
1645     g_tmpMap[startY][startX]=1;
1646     g_tmpRoute[g_stackPointer][0] = startX;
1647     g_tmpRoute[g_stackPointer][1] = startY;
1648     g_stackPointer++;
1649
1650     // ターゲットに到達したとき、スタック深度が今までより浅かったらそれを保存する
1651     if((( g_target_x == startX )&&( g_target_y == startY )&&( g_stackPointer < g_shallowDepth )))
1652     {
1653         g_shallowDepth = g_stackPointer;  // 最浅スタック深度更新
1654         int  j0 = 0;
1655         for( j0 = 0; j0 < g_shallowDepth; j0++ ) {
1656             g_moveRoute[j0][0] = g_tmpRoute[j0][0];
1657             g_moveRoute[j0][1] = g_tmpRoute[j0][1];
1658         }
1659     }
1660
1661     // 再帰法で移動ルートを探し出す
1662     // 配列の添え字と関数の引数が逆になっていることに要注意
1663     i0 = g_selectRange[startY][startX];
1664     if(g_selectRange[startY-1][startX] > 0)
1665         if(( g_selectRange[startY-1][startX]   < i0 )&&(g_tmpMap[startY-1][startX] == 0 )
1666            ){
1667             [self checkRoute:startX startY:startY -1];
1668         }   // 上
1669     if(g_selectRange[startY+1][startX] > 0)
1670         if(( g_selectRange[startY+1][startX]  < i0 )&&(g_tmpMap[startY+1][startX] == 0 )
1671            ){
1672             [self checkRoute:startX startY:startY +1];
1673         }   // 下
1674     if(g_selectRange[startY][startX-1] > 0)
1675         if(( g_selectRange[startY][startX-1]  < i0 )&&(g_tmpMap[startY][startX-1] == 0 )
1676            ){
1677             [self checkRoute:startX-1 startY:startY];
1678         }   // 右
1679     if(g_selectRange[startY][startX+1] > 0)
1680         if(( g_selectRange[startY][startX+1]  < i0 )&&(g_tmpMap[startY][startX+1] == 0 )
1681            ){
1682             [self checkRoute:startX+1 startY:startY];
1683         }   // 左
1684
1685     g_stackPointer--;                // スタックから捨てる
1686     //g_tmpMap[startY][startX] = 0;    // 別経路探索のため
1687
1688 }
1689
1690
1691 //-------------------------------------------------------------------searchRute
1692 -(void)searchRoute2{
1693     int i0;
1694
1695     // ルートテンポラリとルートバッファの初期化
1696     for( i0 = 0; i0 < 2100; i0++ )
1697     { g_tmpRoute2[i0][0] = 0; g_tmpRoute2[i0][1] = 0; g_moveRoute2[i0][0] = 0;
1698         g_moveRoute2[i0][1] = 0; }
1699
1700     for(int i = 0;i < 2100;i++){// テンポラリマップのゼロリセット
1701         for(int j = 0;j< 2100;j++){
1702             g_tmpMap2[j][i] = 0;
1703         }
1704     }
1705     g_stackPointer = 0;              // スタックポインタ初期化
1706     g_shallowDepth = 1002;   //「最も浅いスタック」を持たせるために、// 最も深い値を与えておく
1707
1708     [self checkRoute:g_cursol_x startY:g_cursol_y];
1709
1710     // 経路をテンポラリマップに書き込む
1711     i0 = 0;
1712     g_moveCount = 0;
1713     while( i0 < g_shallowDepth)
1714     {
1715         g_tmpMap2[g_moveRoute2[i0][1]][g_moveRoute2[i0][0]] = 1;
1716
1717         i0++;
1718     }
1719 }
1720
1721 //-------------------------------------------------------------------checkRout
1722 -(void)checkRoute2:(int)startX startY:(int)startY{
1723     int i0 = 0;
1724
1725     g_tmpMap2[startY][startX]=1;
1726     g_tmpRoute2[g_stackPointer][0] = startX;
1727     g_tmpRoute2[g_stackPointer][1] = startY;
1728     g_stackPointer++;
1729
1730     // ターゲットに到達したとき、スタック深度が今までより浅かったらそれを保存する
1731     if((( g_target_x == startX )&&( g_target_y == startY )&&( g_stackPointer < g_shallowDepth ))|| ((cpuTargX == startX ) && (cpuTargY == startY)))
1732     {
1733         g_shallowDepth = g_stackPointer;  // 最浅スタック深度更新
1734         int  j0 = 0;
1735         for( j0 = 0; j0 < g_shallowDepth; j0++ ) {
1736             g_moveRoute2[j0][0] = g_tmpRoute2[j0][0];
1737             g_moveRoute2[j0][1] = g_tmpRoute2[j0][1];
1738         }
1739     }
1740
1741     // 再帰法で移動ルートを探し出す
1742     // 配列の添え字と関数の引数が逆になっていることに要注意
1743     i0 = g_selectRange[startY][startX];
1744     if(g_selectRange[startY-1][startX] > 0)
1745         if(( g_selectRange[startY-1][startX]   < i0 )&&(g_tmpMap2[startY-1][startX] == 0 )
1746            ){
1747             [self checkRoute:startX startY:startY -1];
1748         }   // 上
1749     if(g_selectRange[startY+1][startX] > 0)
1750         if(( g_selectRange[startY+1][startX]  < i0 )&&(g_tmpMap2[startY+1][startX] == 0 )
1751            ){
1752             [self checkRoute:startX startY:startY +1];
1753         }   // 下
1754     if(g_selectRange[startY][startX-1] > 0)
1755         if(( g_selectRange[startY][startX-1]  < i0 )&&(g_tmpMap2[startY][startX-1] == 0 )
1756            ){
1757             [self checkRoute:startX-1 startY:startY];
1758         }   // 右
1759     if(g_selectRange[startY][startX+1] > 0)
1760         if(( g_selectRange[startY][startX+1]  < i0 )&&(g_tmpMap2[startY][startX+1] == 0 )
1761            ){
1762             [self checkRoute:startX+1 startY:startY];
1763         }   // 左
1764
1765     g_stackPointer--;                // スタックから捨てる
1766     //g_tmpMap[startY][startX] = 0;    // 別経路探索のため
1767
1768 }
1769
1770
1771 -(void)modeCPUturn{
1772
1773     enum{
1774
1775         MODE_CPU_IDLE,
1776         MODE_CPU_SEARCH,
1777         MODE_CPU_MOVE,
1778         MODE_CPU_ATTACK,
1779         MODE_CPU_BATTLE,
1780         MODE_CPU_BUILD,
1781         MODE_CPU_EMPLOY,
1782         MODE_CPU_STANBY
1783     };
1784
1785
1786     static int cpuMODE = MODE_CPU_IDLE;
1787
1788     switch (cpuMODE) {
1789         case MODE_CPU_IDLE:
1790             if(coolTime)
1791                 return;
1792
1793             if(stanbyFlag)
1794                 return;
1795
1796             if(unitMoveEndFlag){
1797                 pushStanbyFlag = true;
1798                 UA = NULL;
1799                 cpuIsAttackingFlag = false;
1800             }
1801
1802             if(setBattleModeFlag)
1803                 return;
1804
1805             if(messageDialog)
1806                 return;
1807             if(endGameCondition)
1808                 return;
1809             if(battleFlag || battleRdy || battleSetUp)
1810                 return;
1811
1812             wtRdy = true;
1813             unitMoveEndFlag = false;
1814             CPUAttackFlag = false;
1815             CPUAttackFlag2 = false;
1816             if(cpuAImodeflag && unitBreak->C.nameID)
1817                 cpuMODE = MODE_CPU_SEARCH;
1818             possionX = unitBreak->x;
1819             possionY = unitBreak->y;
1820             currentPosX = possionX;
1821             currentPosY = possionY;
1822             Uselected = unitBreak;
1823             break;
1824         case MODE_CPU_SEARCH:
1825             pushStanbyFlag = false;
1826             [self makeEnemyAI];
1827             [self cpuSearchEnemy];
1828             if(Utarget) NSLog(@"Utarg %d", Utarget->number);
1829             else NSLog(@"Utarg NULL");
1830             cpuModeMOVEflag = true;
1831             if(unitNoMoveStanbyFlag){
1832                 static int waitTimer = 50;
1833                 cpuModeATTACKflag = true;
1834                 if (waitTimer > 0) {
1835                     waitTimer--;
1836                     return;
1837                 }else{
1838                     waitTimer = 50;
1839                     unitNoMoveFlag = true;
1840                     U = UTop;
1841
1842                     while (U->number != wtUnitNum) {
1843                         U = U->next;
1844                     }
1845
1846                     if(!wtMovedFlag && !wtAttackedFlag && unitNoMoveFlag){
1847                         U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
1848                     }else if(wtMovedFlag && wtAttackedFlag){
1849                         U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
1850                     }else if(wtMovedFlag){
1851                         U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
1852                     }else if(wtAttackedFlag){
1853                         U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
1854                     }
1855
1856
1857
1858                     B = BTop;
1859                     while (B) {
1860                         if(B->x == wtPx && B->y == wtPy && B->C.capture){
1861                             buildCaptureFlag = true;
1862                             unitMoveEndFlag = true;
1863                         }
1864                         B = B->next;
1865                     }B = BTop;
1866                     pushStanbyFlag = true;
1867
1868                     cpuModeMOVEflag = false;
1869                     cpuModeATTACKflag = false;
1870                     cpuAImodeflag = false;
1871                     moveFlag = false;
1872                     stanbyFlag = true;
1873                     wtMovedFlag = true;
1874                     CPUAttackFlag = false;
1875                     CPUAttackFlag2 = false;
1876
1877                     unitNoMoveStanbyFlag = false;
1878
1879                     cpuMODE = MODE_CPU_BUILD;
1880
1881                 }
1882
1883                 return;
1884             }
1885             wtMovedFlag = true;
1886             cpuMODE = MODE_CPU_MOVE;
1887             if(unitNoMoveFlag){
1888                 wtMovedFlag = false;
1889                 cpuModeATTACKflag = true;
1890                 CPUAttackFlag = true;
1891                 cpuMODE = MODE_CPU_ATTACK;
1892             }
1893             break;
1894         case MODE_CPU_MOVE:
1895             moveFlag = true;
1896             cpuModeATTACKflag = true;
1897
1898
1899             if ([self cpuMoveFunc] && unitMoveEndFlag) {
1900                 cpuMODE = MODE_CPU_ATTACK;
1901             }
1902            // NSLog(@"test[%d,%d][%d,%d]", unitBreak->x, unitBreak->y, possionX, possionY);
1903            // NSLog(@"test[%d]", unitNoMoveFlag);
1904             possionX = g_target_y;
1905             possionY = g_target_x;
1906             if(unitNoMoveFlag){
1907                 if(CPUAttackFlag  && Utarget){
1908                     cpuMODE = MODE_CPU_ATTACK;
1909                 }else{
1910                     cpuMODE = MODE_CPU_BUILD;
1911                 }
1912             }
1913
1914             break;
1915         case MODE_CPU_ATTACK:
1916
1917             if(!Utarget){
1918                 cpuMODE = MODE_CPU_BUILD;
1919                 CPUAttackFlag = false;
1920                 return;
1921             }
1922
1923             if(!CPUAttackFlag){
1924                 cpuMODE = MODE_CPU_BUILD;
1925
1926                 return;
1927             }else{
1928                 //unitNoMoveFlag = false;
1929                 CPUAttackFlag = true;
1930                 unitCPUAttackFlag = true;
1931                 cpuMODE = MODE_CPU_BATTLE;
1932                 return;
1933             }
1934             break;
1935         case MODE_CPU_BATTLE:
1936
1937             if(cpuModeBATTLEendFlag){
1938
1939
1940                 if(cpuModeBATTLEendFlag){
1941
1942                     static int waitTimer0 = 50;
1943
1944                     if (waitTimer0 > 0) {
1945                         waitTimer0--;
1946                         return;
1947                     }else{
1948                         waitTimer0 = 50;
1949                     pushStanbyFlag = true;
1950
1951                     cpuModeMOVEflag = false;
1952                     cpuModeATTACKflag = false;
1953                     cpuAImodeflag = false;
1954                     moveFlag = false;
1955                     //stanbyFlag = true;
1956                     wtMovedFlag = true;
1957                     CPUAttackFlag2 = false;
1958                     battleWindowFlag = true;
1959
1960                     cpuModeBATTLEendFlag = false;
1961                     cpuOMFGmoveATKfixFlag = false;
1962                     cpuMODE = MODE_CPU_EMPLOY;
1963                     }
1964                 }
1965
1966                 return;
1967             }
1968             else if((CPUAttackFlag && unitMoveEndFlag )|| CPUAttackFlag2){
1969
1970                 static int waitTimer = 50;
1971
1972                 if (waitTimer > 0) {
1973                     waitTimer--;
1974                     return;
1975                 }else{
1976                     waitTimer = 50;
1977                     if(!cpuAtkExtendFlag){
1978                         CPUAttackSubmitFlag = true;
1979                         battleWindowFlag = true;
1980                         cpuModeBATTLEflag = true;
1981
1982                         CPUAttackFlag2 = false;
1983                     }else{
1984                         CPUAttackSubmitFlag = true;
1985                         battleWindowFlag = false;
1986                         cpuModeBATTLEflag = true;
1987                         battleFlag = false;
1988                         CPUAttackFlag2 = false;
1989                         cpuAtkExtendFlag = false;
1990                         cpuAtkExtendFlag2 = true;
1991                         cpuOMFGmoveATKfixFlag = true;
1992                     }
1993                 }
1994             }else{
1995
1996                 return;
1997             }
1998
1999             cpuMODE = MODE_CPU_EMPLOY;
2000
2001             break;
2002         case MODE_CPU_BUILD:
2003
2004             B = BTop;
2005             while (B) {
2006                 if(B->x == possionX && B->y == possionY)
2007                     break;
2008                 B = B->next;
2009             }
2010
2011             SKILL *ST = unitBreak->C.S;
2012
2013             int UT = 0;
2014
2015             if(unitBreak->team == 0){
2016                 UT = 0;
2017             }else if(unitBreak->team == 2){
2018                 UT = 1;
2019             }else if(unitBreak->team == 1){
2020                 UT = 2;
2021             }
2022
2023             if(cpuBuildDoneFlag){
2024                 if(unitNoMoveFlag){
2025
2026                     while(unitBreak->C.S){
2027                         if(unitBreak->C.S->type == 1){
2028                             for(int i = 0;unitBreak->C.S->list[i] > 0;i++){
2029                                 if(i == ST6type){
2030                                     P[UT].resource -= BC[unitBreak->C.S->list[i]-1].Csupply;
2031                                     P[UT].food -= BC[unitBreak->C.S->list[i]-1].Cfood;
2032                                     P[UT].money -= BC[unitBreak->C.S->list[i]-1].Cmoney;
2033                                     ST6type = 0;
2034                                 }
2035                             }
2036                         }
2037                         unitBreak->C.S = unitBreak->C.S->next;
2038                     }unitBreak->C.S = ST;
2039
2040
2041                 B->C.invisible = false;
2042                 cpuBuildDoneFlag = false;
2043                 cpuMODE = MODE_CPU_EMPLOY;
2044             }else if(wtMovedFlag){
2045
2046                 while(unitBreak->C.S){
2047                     if(unitBreak->C.S->type == 1){
2048                         for(int i = 0;unitBreak->C.S->list[i] > 0;i++){
2049                             if(i == ST6type){
2050                                 P[UT].resource -= BC[unitBreak->C.S->list[i]-1].Csupply;
2051                                 P[UT].food -= BC[unitBreak->C.S->list[i]-1].Cfood;
2052                                 P[UT].money -= BC[unitBreak->C.S->list[i]-1].Cmoney;
2053                                 ST6type = 0;
2054                             }
2055                         }
2056                     }
2057                     unitBreak->C.S = unitBreak->C.S->next;
2058                 }unitBreak->C.S = ST;
2059                 NSLog(@"BTop %@", BTop->C.name);
2060                 B->C.invisible = false;
2061                 cpuBuildDoneFlag = false;
2062                 cpuMODE = MODE_CPU_EMPLOY;
2063             }else if(unitMoveEndFlag){
2064
2065                 while(unitBreak->C.S){
2066                     if(unitBreak->C.S->type == 1){
2067                         for(int i = 0;unitBreak->C.S->list[i] > 0;i++){
2068                             if(i == ST6type){
2069                                 P[UT].resource -= BC[unitBreak->C.S->list[i]-1].Csupply;
2070                                 P[UT].food -= BC[unitBreak->C.S->list[i]-1].Cfood;
2071                                 P[UT].money -= BC[unitBreak->C.S->list[i]-1].Cmoney;
2072                                 ST6type = 0;
2073                             }
2074                         }
2075                     }
2076                     unitBreak->C.S = unitBreak->C.S->next;
2077                 }unitBreak->C.S = ST;
2078
2079                 B->C.invisible = false;
2080                 cpuBuildDoneFlag = false;
2081                 cpuMODE = MODE_CPU_EMPLOY;
2082             }
2083
2084                 B = BTop;
2085                 return;
2086             }
2087             B = BTop;
2088             cpuMODE = MODE_CPU_EMPLOY;
2089             break;
2090         case MODE_CPU_EMPLOY:
2091             [self cpuEmployment];
2092             cpuMODE = MODE_CPU_STANBY;
2093             break;
2094         case MODE_CPU_STANBY:
2095
2096             if(!Utarget){
2097                 CPUAttackFlag = false;
2098             }
2099
2100             if(!CPUAttackFlag){
2101                 U = UTop;
2102
2103                 while (U->number != wtUnitNum) {
2104                     U = U->next;
2105                 }
2106
2107                 if(!wtMovedFlag && !wtAttackedFlag && unitNoMoveFlag){
2108                     U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
2109                 }else if(wtMovedFlag && wtAttackedFlag){
2110                     U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
2111                 }else if(wtMovedFlag){
2112                     U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
2113                 }else if(wtAttackedFlag){
2114                     U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
2115                 }
2116
2117                 U = UTop;
2118
2119
2120                 wtRdy = false;
2121                 pushStanbyFlag = true;
2122
2123                 cpuModeMOVEflag = false;
2124                 cpuModeATTACKflag = false;
2125                 cpuAImodeflag = false;
2126                 moveFlag = false;
2127                 stanbyFlag = true;
2128                 wtMovedFlag = true;
2129                 unitNoMoveFlag = false;
2130                 CPUAttackFlag = false;
2131                 CPUAttackFlag2 = false;
2132
2133                 cpuModeBATTLEendFlag = false;
2134                 //Utarget = NULL;
2135                 cpuMODE = MODE_CPU_IDLE;
2136                 cpuIsAttackingFlag = false;
2137                 UA = NULL;
2138                 return;
2139             }
2140
2141
2142             //おまんちん
2143             U = UTop;
2144             while (U->number != wtUnitNum) {
2145                 U = U->next;
2146             }
2147
2148             if(!wtMovedFlag && !wtAttackedFlag && unitNoMoveFlag){
2149                 U->C.S_C.WT = floor(U->C.S_M.WT/4 + 0.5);
2150             }else if(wtMovedFlag && wtAttackedFlag){
2151                 U->C.S_C.WT =  floor(U->C.S_M.WT + 0.5);
2152             }else if(wtMovedFlag){
2153                 U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
2154             }else if(wtAttackedFlag){
2155                 U->C.S_C.WT =  floor(U->C.S_M.WT/2 + 0.5);
2156             }
2157
2158             U = UTop;
2159
2160
2161             wtRdy = true;
2162
2163             pushStanbyFlag = true;
2164
2165             cpuModeMOVEflag = false;
2166             cpuModeATTACKflag = false;
2167             cpuAImodeflag = false;
2168             moveFlag = false;
2169             stanbyFlag = true;
2170             wtMovedFlag = true;
2171             CPUAttackFlag = false;
2172             CPUAttackFlag2 = false;
2173             unitNoMoveFlag = false;
2174             cpuModeBATTLEendFlag = false;
2175             cpuMODE = MODE_CPU_IDLE;
2176             //if(Utarget) NSLog(@"Utarg2 %d", Utarget->number);
2177             break;
2178         default:
2179             cpuMODE = MODE_CPU_IDLE;
2180             break;
2181     }
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198 }
2199
2200
2201
2202 -(void)cpuEmployment{
2203
2204     B = BTop;
2205     while(B){
2206
2207         if(unitNum[B->x][B->y] < 0 && unitBreak->team == B->team){
2208
2209             BUILDCHIP B0 = BC[buildNum[B->x][B->y]];
2210             RESEARCH *Rtop = B0.R;
2211             UNITCHIP *BU;
2212
2213             int UT = 0;
2214
2215             if(unitBreak->team == 0){
2216                 UT = 0;
2217             }else if(unitBreak->team == 2){
2218                 UT = 1;
2219             }else if(unitBreak->team == 1){
2220                 UT = 2;
2221             }
2222
2223             while(B0.R){
2224                 BU = B0.R->U;
2225                 BRU = BU;
2226                 if(B->makeLv >= B0.R->Lv && unitNum[B->x][B->y] < 0){
2227
2228                     int rdmCnt = rand()%100;
2229
2230                     if(BU && rdmCnt > 60){
2231                         if(BU->S_M.cSupply <= P[UT].resource &&
2232                            BU->S_M.cFood <= P[UT].food &&
2233                            BU->S_M.cMoney <= P[UT].money){
2234
2235
2236                             P[UT].resource -= BU->S_M.cSupply;
2237                             P[UT].food -= BU->S_M.cFood;
2238                             P[UT].money -= BU->S_M.cMoney;
2239
2240                             unitNum[B->x][B->y] = BU->chipNumb;
2241                             unitTeam[B->x][B->y] = B->team;
2242                             possionX = B->x;
2243                             possionY = B->y;
2244                             [self addUnitStatusFix];
2245                             break;
2246                         }
2247                     }
2248                 }
2249
2250                     B0.R = B0.R->next;
2251             }B0.R = Rtop;
2252
2253         }
2254         B = B->next;
2255     }B = BTop;
2256 }
2257
2258 -(void)addUnitStatusFix{
2259     //おまんちん
2260     int omgCnt = 0;
2261     UTop = U;
2262     while (U->next) {omgCnt++;
2263         U = U->next;
2264     }
2265     U->next = calloc(1, sizeof(UNIT));
2266     U = U->next;
2267     U->next = NULL;
2268     if(omgCnt == 0) UTop = U;
2269     U->number = registerNum;
2270
2271     for(int i = 0;i < UCN;i++){
2272         if([U->C.nameID isEqualToString:UC[i].nameID])
2273             U->chipNumber = i;
2274     }
2275
2276     U->chipNumber = unitNum[possionX][possionY];
2277     U->chipNumberL = loadNum[possionX][possionY];
2278     U->C.chipNumb = unitNum[possionX][possionY];
2279     U->CL.chipNumb = loadNum[possionX][possionY];
2280     U->x = possionX;
2281     U->y = possionY;
2282     U->C = *BRU;
2283     if(unitTeam[possionX][possionY] == 0 || unitTeam[possionX][possionY] == 1){
2284         U->team = 0;
2285         if(unitTeam[possionX][possionY] == 1){
2286             U->joinArmyFromNext = true;
2287             U->persuasion = true;
2288         }
2289         if(MF[MFselectedRow+1].MS.playerSet1 == 2){
2290             U->CPU = true;
2291         }
2292     }
2293     if(unitTeam[possionX][possionY] == 2 || unitTeam[possionX][possionY] == 3){
2294         U->team = 2;
2295         if(unitTeam[possionX][possionY] == 3){
2296             U->joinArmyFromNext = true;
2297             U->persuasion = true;
2298         }
2299         if(MF[MFselectedRow+1].MS.playerSet2 == 2){
2300             U->CPU = true;
2301         }
2302     }
2303     if(unitTeam[possionX][possionY] == 4 || unitTeam[possionX][possionY] == 5){
2304         U->team = 1;
2305         if(unitTeam[possionX][possionY] == 5){
2306             U->joinArmyFromNext = true;
2307             U->persuasion = true;
2308         }
2309         U->CPU = true;
2310     }
2311     if(unitTeam[possionX][possionY] == -1){
2312         U->team = -1;
2313         if(unitTeam[possionX][possionY] == 0){
2314             U->joinArmyFromNext = false;
2315             U->persuasion = true;
2316         }
2317         U->CPU = true;
2318     }
2319     [self SetUnitStatusFix:unitNum[possionX][possionY]];
2320     unitColorInitFlag = true;
2321     registerNum++;
2322     U = UTop;
2323 }
2324
2325 -(void)SetUnitStatusFix:(int)UN{
2326
2327     U->C = UC[UN];
2328     U->C.S_C.vigor = 100;
2329
2330     ATTACK *Atop;
2331     ATTACK *AtopE1;
2332     ATTACK *AtopE2;
2333     ATTACK *UAtop;
2334     Atop = UC[UN].A;
2335     AtopE1 = UC[UN].eHandL.A;
2336     AtopE2 = UC[UN].eHandR.A;
2337     U->C.A = calloc(1, sizeof(ATTACK));
2338     UAtop = U->C.A;
2339
2340     bool ow1 = false;
2341     bool ow2 = false;
2342
2343     while(UC[UN].eHandR.A != NULL){ow1 = true;
2344         *U->C.A = *UC[UN].eHandR.A;
2345         U->C.A->next = calloc(1, sizeof(ATTACK));
2346         U->C.A->next->next = NULL;
2347         if(UC[UN].eHandR.A->next != NULL) U->C.A = U->C.A->next;
2348         UC[UN].eHandR.A = UC[UN].eHandR.A->next;
2349         U->C.attackListNum++;
2350     }
2351     UC[UN].eHandR.A = AtopE2;
2352
2353
2354     if(ow1) {
2355         U->C.A = U->C.A->next;
2356         ow1 = false;
2357     }
2358     while(UC[UN].eHandL.A != NULL){ow2 = true;
2359         *U->C.A = *UC[UN].eHandL.A;
2360         U->C.A->next = calloc(1, sizeof(ATTACK));
2361         U->C.A->next->next = NULL;
2362         if(UC[UN].eHandL.A->next != NULL) U->C.A = U->C.A->next;
2363         UC[UN].eHandL.A = UC[UN].eHandL.A->next;
2364         U->C.attackListNum++;
2365     }
2366     UC[UN].eHandL.A = AtopE1;
2367
2368     if(ow2) {
2369         U->C.A = U->C.A->next;
2370         ow2 = false;
2371     }
2372     while(UC[UN].A != NULL){
2373         *U->C.A = *UC[UN].A;
2374         U->C.A->next = calloc(1, sizeof(ATTACK));
2375         U->C.A->next->next = NULL;
2376         if(UC[UN].A->next != NULL) U->C.A = U->C.A->next;
2377         UC[UN].A = UC[UN].A->next;
2378     }
2379     U->C.A->next = NULL;
2380     UC[UN].A = Atop;
2381     U->C.A = UAtop;
2382     if(U->C.A) if(!U->C.A->name)
2383         U->C.A = NULL;
2384
2385 }
2386
2387 -(void)cpuSearchEnemy{
2388     //おまんちん
2389     if(!unitBreak->C.nameID) return;
2390
2391     moveFlag = false;
2392     attackFlag = false;
2393     stanbyFlag = false;
2394     unitMoveEndFlag = false;
2395     possionX = unitBreak->x;
2396     possionY = unitBreak->y;
2397
2398     UCselected = UC[unitNum[unitBreak->x][unitBreak->y]];
2399     LCselected = LC[loadNum[unitBreak->x][unitBreak->y]];
2400
2401     if(unitBreak->chipNumber >= 0) [self LookupMovableRange:unitBreak->y startY:unitBreak->x aPiece:&UC[unitNum[unitBreak->x][unitBreak->y]] turnSide:YES];
2402     if(unitBreak->chipNumberL >= 0) [self LookupMovableRange2:unitBreak->y startY:unitBreak->x aPiece:&LC[loadNum[unitBreak->x][unitBreak->y]] turnSide:YES];
2403
2404     for (int x = 0; x <= chipWidth; x++) {
2405         for (int y = 0; y <= chipHeight; y++) {
2406             g_targUnit[y][x] = 0;
2407         }
2408     }
2409
2410     for (int x = 0; x <= chipWidth; x++) {
2411         for (int y = 0; y <= chipHeight; y++) {
2412             g_entireUnit[y][x] = 0;
2413         }
2414     }
2415
2416     UNIT *UN = U;
2417     for (int x = 0; x <= chipWidth; x++) {
2418         for (int y = 0; y <= chipHeight; y++) {
2419
2420
2421             U = UTop;
2422             while(U){
2423                 if(U->y == x && U->x == y){
2424                     g_entireUnit[y][x] = 1;
2425                 }
2426                 U = U->next;
2427             }U = UTop;
2428         }
2429     }
2430
2431     for (int x = 0; x <= chipWidth; x++) {
2432         for (int y = 0; y <= chipHeight; y++) {
2433
2434
2435             U = UTop;
2436             while(U){
2437                 if(g_attackRangeBeta[y][x] > 0 && U->y == x && U->x == y){
2438                     g_targUnit[y][x] = 1;
2439                 }
2440                 U = U->next;
2441             }U = UTop;
2442         }
2443     }
2444
2445
2446
2447     AUN[1] = unitBreak;
2448     Utarget = NULL;
2449     CPUAttackFlag = false;
2450     CPUAttackFlag2 = false;
2451     eval_point = 0;
2452     U = UTop;
2453     //おまんちん
2454
2455
2456
2457     while (U) {
2458
2459         for (int x = 0; x <= chipWidth; x++) {
2460             for (int y = 0; y <= chipHeight; y++) {
2461                 g_attackRangeTheta[y][x] = 0;
2462             }
2463         }
2464         [self checkRangeAttack:U->y startY:U->x leftPow:unitBreak->atkRange+1 pieceType:U->C.S_C.typeMONS aMap:g_attackRangeTheta aPiece:&U->C i:unitBreak->atkRange+1 ];
2465
2466         for (int i = 1;i <= chipWidth;i++) {
2467             for(int k = 1;k <= chipHeight;k++){
2468                 if(g_attackRangeTheta[i][k] > 0)
2469                 g_attackRangeTheta[i][k] =  unitBreak->atkRange+1 - g_attackRangeTheta[i][k];
2470             }
2471         }
2472
2473
2474         ATTACK *AT = unitBreak->C.A;
2475         for(int i = 0;i < crCAL1;i++){
2476             AT = AT->next;
2477         }
2478
2479         while (1) {
2480             if(g_attackRangeTheta[unitBreak->x][unitBreak->y] > 0 && !U->dead && AT->D->sort == 1){
2481
2482                 if(unitBreak->team == 2){
2483                     if(U->team == 2 && unitBreak->team == 2){
2484
2485                     }else{
2486                         break;
2487
2488                     }
2489                 }
2490
2491                 if(unitBreak->team == 0 || unitBreak->team == 1){
2492                     if(((U->team == 1 && unitBreak->team == 0) || (U->team == 0 && unitBreak->team == 1) ||
2493                         (U->team == 0 && unitBreak->team == 0) || (U->team == 1 && unitBreak->team == 1))
2494                        ){
2495
2496                     }else{
2497                         break;
2498
2499                     }
2500                 }
2501
2502                 //NSLog(@"HP %g HPH %g", U->C.S_C.HP, U->C.S_M.HP*70/100);
2503                 if(AT->D->sort == 1 && U->C.S_C.HP <= U->C.S_M.HP*70/100){
2504
2505                 }else{
2506                     break;
2507                 }
2508
2509                 AUN[1] = unitBreak->number;
2510                 DUN[1] = U->number;
2511                 Utarget = U;
2512                 unitBreak->atkRange = g_attackRangeTheta[unitBreak->x][unitBreak->y];
2513                 g_target_x = unitBreak->y;
2514                 g_target_y = unitBreak->x;
2515                 unitNoMoveFlag = true;
2516                 CPUAttackFlag = true;
2517                 CPUAttackFlag2 = true;
2518                 cpuIsAttackingFlag = true;
2519                 U = UTop;
2520                 goto w000p;
2521             }
2522             break;
2523         }
2524
2525
2526         if(!U->dead && AT->D->sort == 1){
2527
2528             if(unitBreak->team == 2){
2529                 if(U->team == 2 && unitBreak->team == 2){
2530
2531                 }else{
2532
2533                     goto w00p2;
2534
2535                 }
2536             }
2537
2538             if(unitBreak->team == 0 || unitBreak->team == 1){
2539                 if(((U->team == 1 && unitBreak->team == 0) || (U->team == 0 && unitBreak->team == 1) ||
2540                    (U->team == 0 && unitBreak->team == 0) || (U->team == 1 && unitBreak->team == 1))
2541                    ){
2542
2543                 }else{
2544
2545                     goto w00p2;
2546
2547                 }
2548             }
2549
2550
2551             // NSLog(@"HP %g HPH %g", U->C.S_C.HP, U->C.S_M.HP*70/100);
2552             if(U->C.S_C.HP <= U->C.S_M.HP*70/100){
2553
2554             }else{
2555                 goto w00p2;
2556             }
2557
2558             for (int x = 1; x <= chipWidth; x++) {
2559                 for (int y = 1; y <= chipHeight; y++) {
2560                     if(g_attackRangeTheta[y][x] > 0 && g_selectRange[y][x] > 0 && g_entireUnit[y][x] == 0
2561                        && g_attackRangeTheta[y][x] == unitBreak->atkRange){
2562
2563
2564                         int point = (unitBreak->atkRange - g_attackRangeBeta[y][x])*20 + g_selectRange[y][x]*50;
2565
2566                         if(eval_point < point){
2567                             eval_point = point;
2568                             Utarget = U;
2569                             unitBreak->atkRange = g_attackRangeTheta[y][x];
2570                             g_target_x = x;
2571                             g_target_y = y;
2572                             CPUAttackFlag = true;
2573                             AUN[1] = unitBreak->number;
2574                             DUN[1] = U->number;
2575                         }
2576
2577                     }
2578
2579                 }
2580
2581
2582             }
2583         }
2584
2585     w00p2:
2586         U = U->next;
2587     }
2588
2589     ATTACK *AT = unitBreak->C.A;
2590     for(int i = 0;i < crCAL1;i++){
2591         AT = AT->next;
2592     }
2593
2594     if(!Utarget){
2595         [self healBreak];//回復の対象がいない時、回復以外にする
2596     }else if(Utarget){
2597         U = UTop;
2598         goto w000p;
2599     }
2600
2601
2602     U = UTop;
2603
2604     while (U) {
2605
2606         for (int x = 0; x <= chipWidth; x++) {
2607             for (int y = 0; y <= chipHeight; y++) {
2608                 g_attackRangeTheta[y][x] = 0;
2609             }
2610         }
2611         [self checkRangeAttack:U->y startY:U->x leftPow:unitBreak->atkRange+1 pieceType:U->C.S_C.typeMONS aMap:g_attackRangeTheta aPiece:&U->C i:unitBreak->atkRange+1 ];
2612
2613         for (int i = 1;i <= chipWidth;i++) {
2614             for(int k = 1;k <= chipHeight;k++){
2615                 if(g_attackRangeTheta[i][k] > 0)
2616                 g_attackRangeTheta[i][k] =  unitBreak->atkRange+1 - g_attackRangeTheta[i][k];
2617             }
2618         }
2619
2620         ATTACK *AT = unitBreak->C.A;
2621         for(int i = 0;i < crCAL1;i++){
2622             AT = AT->next;
2623         }
2624
2625         while (1) {
2626             if(g_attackRangeTheta[unitBreak->x][unitBreak->y] > 0 && !U->dead &&
2627                unitBreak->team != U->team && AT->D->sort != 1){
2628
2629                 if(unitBreak->team == 0)
2630                     if(U->team == 1)
2631                         break;
2632                 if(unitBreak->team == 1)
2633                     if(U->team == 0)
2634                         break;
2635
2636
2637                 AUN[1] = unitBreak->number;
2638                 DUN[1] = U->number;
2639                 bool rangeChanged = false;
2640                 if(unitBreak->atkRange != g_attackRangeTheta[unitBreak->x][unitBreak->y]){
2641
2642                     rangeChanged = true;
2643                 }
2644
2645
2646                 unitBreak->atkRange = g_attackRangeTheta[unitBreak->x][unitBreak->y];
2647                 Utarget = U;
2648                 g_target_x = unitBreak->y;
2649                 g_target_y = unitBreak->x;
2650                 unitNoMoveFlag = true;
2651                 CPUAttackFlag = true;
2652                 CPUAttackFlag2 = true;
2653                 cpuIsAttackingFlag = true;
2654
2655                 if(rangeChanged){
2656                     [self atkSelectionFix];
2657                 }
2658
2659                 goto w000p;
2660             }
2661             break;
2662         }
2663
2664
2665         if(!U->dead && unitBreak->team != U->team && unitBreak->C.A->D->sort != 1){
2666
2667             if(unitBreak->team == 0)
2668                 if(U->team == 1)
2669                     goto w00p;
2670             if(unitBreak->team == 1)
2671                 if(U->team == 0)
2672                     goto w00p;
2673
2674             for (int x = 1; x <= chipWidth; x++) {
2675                 for (int y = 1; y <= chipHeight; y++) {
2676                     if(g_attackRangeTheta[y][x] > 0 && g_selectRange[y][x] > 0 && g_entireUnit[y][x] == 0
2677                        && g_attackRangeTheta[y][x] == unitBreak->atkRange){
2678
2679
2680                         int point = (unitBreak->atkRange - g_attackRangeBeta[y][x])*20 + g_selectRange[y][x]*50;
2681
2682                         if(eval_point < point){
2683                             eval_point = point;
2684                             Utarget = U;
2685
2686                             bool rangeChanged = false;
2687                             if(unitBreak->atkRange != g_attackRangeTheta[y][x]){
2688
2689                                 rangeChanged = true;
2690                             }
2691
2692                             unitBreak->atkRange = g_attackRangeTheta[y][x];
2693
2694                             if(rangeChanged){
2695                                 [self atkSelectionFix];
2696                             }
2697
2698                             g_target_x = x;
2699                             g_target_y = y;
2700                             CPUAttackFlag = true;
2701                             AUN[1] = unitBreak->number;
2702                             DUN[1] = U->number;
2703                         }
2704
2705                     }
2706
2707                 }
2708
2709
2710             }
2711         }
2712
2713     w00p:
2714         U = U->next;
2715     }U = UTop;
2716
2717     if(Utarget){
2718     w000p:
2719         if(!Utarget)
2720             goto w00t;
2721         for (int x = 0; x <= chipWidth; x++) {
2722             for (int y = 0; y <= chipHeight; y++) {
2723                 g_attackRangeTheta[y][x] = 0;
2724             }
2725         }
2726         [self checkRangeAttack:Utarget->y startY:Utarget->x leftPow:unitBreak->atkRange+1 pieceType:U->C.S_C.typeMONS aMap:g_attackRangeTheta aPiece:&U->C i:unitBreak->atkRange+1 ];
2727
2728
2729         for (int i = 1;i <= chipWidth;i++) {
2730             for(int k = 1;k <= chipHeight;k++){
2731                 if(g_attackRangeTheta[i][k] > 0)
2732                 g_attackRangeTheta[i][k] =  unitBreak->atkRange+1 - g_attackRangeTheta[i][k];
2733             }
2734         }
2735
2736
2737         if(g_attackRangeTheta[g_target_y][g_target_x] != unitBreak->atkRange){
2738             Utarget = NULL;
2739             goto FUCKYOU;
2740         }
2741
2742
2743         for (int k = 0; k <= chipWidth; k++) {
2744             for (int g = 0; g <= chipHeight; g++) {
2745                 g_enemyRange[g][k] = 0;
2746             }
2747         }
2748
2749         //[self checkEnemyRange:unitBreak->atkRange+1 cntNum:0 tX:Utarget->x tY:Utarget->y aMap:g_enemyRange];
2750
2751         //unitBreak->atkRange = unitBreak->atkRange+1 - g_enemyRange[g_target_x][g_target_y];
2752
2753
2754
2755         if(UA){
2756             if(UA->extent > 0){
2757                 if(1){
2758                     U = UTop;
2759                     int i = 1;
2760                     while(U && AUN[1] > i){i++;
2761                         U = U->next;
2762                     }
2763                     crCAL = crCAL1;
2764                     attackExceptNumber = U->number;
2765                     if(U->chipNumberL < 0){
2766
2767                         [self LookupAttackRangeExtent:Utarget->y startY:Utarget->x aPiece:&U->C turnSide:YES];
2768                         U = UTop;
2769                     }else {
2770
2771                         [self LookupAttackRangeExtent2:Utarget->y startY:Utarget->x aPiece:&U->CL turnSide:YES];
2772                     }
2773                     U = UTop;
2774
2775                 }
2776
2777                 attackExtentFlag2 = true;
2778                 [self cpuATKextentFunc];
2779                 atkExtentFlag = true;
2780                 cpuAtkExtendFlag = true;
2781             }else{
2782                 atkExtentFlag = false;
2783             }
2784         }
2785         crCAL = crCAL1;
2786
2787
2788         //NSLog(@"UtargNUm %d", Utarget->number);
2789         return;
2790     }
2791     FUCKYOU:{}
2792     enum{
2793         MC_ANTEI,
2794         MC_FUANTEI,
2795         MC_CHIKURIN,
2796         MC_MIZUBA,
2797         MC_ASASE,
2798         MC_NAIBU
2799     };
2800
2801     enum{
2802         BC_ANTEI,
2803         BC_CHIKURIN,
2804         BC_ASASE,
2805         BC_SONOTA
2806     };
2807
2808
2809
2810     if(!Utarget){
2811     w00t:{}
2812         eval_point = 999;
2813         g_target_x = 0;
2814         g_target_y = 0;
2815
2816         U = UTop;
2817         while (U) {
2818
2819             if(!U->dead && U->team != unitBreak->team){
2820                 if(unitBreak->team == 0)
2821                     if(U->team == 1)
2822                         goto w0000p;
2823                 if(unitBreak->team == 1)
2824                     if(U->team == 0)
2825                         goto w0000p;
2826
2827                 for (int x = 1; x <= chipWidth; x++) {
2828                     for (int y = 1; y <= chipHeight;y++) {
2829                         if(g_selectRange[y][x] > 0 && g_entireUnit[y][x] == 0){
2830                             int dist = abs(x - U->y) + abs(y - U->x);
2831
2832
2833                             if(buildNum[y][x] >= 0){
2834                                 if((buildTeam[y][x] == 0 || buildTeam[y][x] == 1) && unitBreak->team == 0)
2835                                     break;
2836                                 if((buildTeam[y][x] == 2 || buildTeam[y][x] == 3) && unitBreak->team == 2)
2837                                     break;
2838                                 if((buildTeam[y][x] == 4 || buildTeam[y][x] == 5) && unitBreak->team == 1)
2839                                     break;
2840
2841                                 dist = 999;
2842                                 g_target_x = x;
2843                                 g_target_y = y;
2844                                 U = UTop;
2845                                 U = UN;
2846                                 possionX = g_target_y;
2847                                 possionY = g_target_x;
2848
2849                                 if(unitBreak->team == 0){
2850                                     buildTeam[y][x] = 0;
2851                                 }
2852                                 if(unitBreak->team == 1){
2853                                     buildTeam[y][x] = 4;
2854                                 }
2855                                 if(unitBreak->team == 2){
2856                                     buildTeam[y][x] = 2;
2857                                 }
2858                                 if(g_target_x == unitBreak->y && g_target_y == unitBreak->x){
2859                                     unitNoMoveStanbyFlag = true;
2860                                 }
2861                                 return;
2862                             }
2863
2864                             int rdmCnt;
2865
2866                             rdmCnt = rand()%100;
2867
2868                             SKILL *ST = unitBreak->C.S;
2869                             if(g_selectRange[y][x] > 0 && g_entireUnit[y][x] == 0)
2870                             while(unitBreak->C.S){
2871                                 if(unitBreak->C.S->type == 1){
2872                             if(rdmCnt > 20)
2873                                 for(int i = 0;unitBreak->C.S->list[i] > 0;i++){
2874                                     if(BC[unitBreak->C.S->list[i]-1].type == BC_CHIKURIN){
2875                                         if(MC[chipNum[g_target_y][g_target_x]].type == MC_CHIKURIN && buildNum[g_target_y][g_target_x] < 0){
2876
2877
2878                                             int rdmCnt2;
2879
2880                                             rdmCnt2 = rand()%100;
2881                                             if(rdmCnt2 > 40) continue;
2882
2883                                             int UT = 0;
2884
2885                                             if(unitBreak->team == 0){
2886                                                 UT = 0;
2887                                             }else if(unitBreak->team == 2){
2888                                                 UT = 1;
2889                                             }else if(unitBreak->team == 1){
2890                                                 UT = 2;
2891                                             }
2892
2893                                             if(BC[unitBreak->C.S->list[i]-1].Csupply <= P[UT].resource &&
2894                                                BC[unitBreak->C.S->list[i]-1].Cfood <= P[UT].food &&
2895                                                BC[unitBreak->C.S->list[i]-1].Cmoney <= P[UT].money
2896                                                ){
2897
2898                                                 if(unitBreak->team == 0){
2899                                                     buildTeam[g_target_y][g_target_x] = 0;
2900                                                 }
2901                                                 if(unitBreak->team == 1){
2902                                                     buildTeam[g_target_y][g_target_x] = 4;
2903                                                 }
2904                                                 if(unitBreak->team == 2){
2905                                                     buildTeam[g_target_y][g_target_x] = 2;
2906                                                 }
2907
2908                                                 dist = 999;
2909                                                 NSLog(@"[%d, %d]", g_target_x, g_target_y);
2910                                                 //g_target_x = x;
2911                                                 //g_target_y = y;
2912                                                 U = UTop;
2913                                                 U = UN;
2914                                                 possionX = g_target_y;
2915                                                 possionY = g_target_x;
2916
2917                                                 buildNum[possionX][possionY] = BC[unitBreak->C.S->list[i]-1].chipNumb;
2918                                                 buildTeam[possionX][possionY] = unitBreak->team;
2919                                                 /*
2920                                                 P[UT].resource -= BC[unitBreak->C.S->list[i]-1].Csupply;
2921                                                 P[UT].food -= BC[unitBreak->C.S->list[i]-1].Cfood;
2922                                                 P[UT].money -= BC[unitBreak->C.S->list[i]-1].Cmoney;
2923                                                 */
2924
2925                                                 //[FS addBuildStatus];
2926                                                 cpuBuildDoneFlag = true;
2927                                                 [self addBuildStatusfix];
2928                                                 ST6type = i;
2929                                                 unitBreak->C.S = ST;
2930                                                 if(g_target_x == unitBreak->y && g_target_y == unitBreak->x){
2931                                                     unitNoMoveStanbyFlag = true;
2932                                                 }
2933                                                 return;
2934                                             }
2935                                         }
2936
2937                                     }
2938                                 }
2939
2940                             rdmCnt = rand()%100;
2941
2942                                 }
2943                                 unitBreak->C.S = unitBreak->C.S->next;
2944                             }
2945                             unitBreak->C.S = ST;
2946                             if(eval_point > dist){
2947                                 eval_point = dist;
2948                                 g_target_x = x;
2949                                 g_target_y = y;
2950                             }
2951                         }
2952                     }
2953                 }
2954
2955             }
2956         w0000p:{}
2957             U = U->next;
2958         }
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968         U = UTop;
2969     }
2970
2971     U = UN;
2972
2973     if(g_target_x == unitBreak->y && g_target_y == unitBreak->x){
2974         unitNoMoveStanbyFlag = true;
2975     }
2976
2977     if(g_target_x == 0 && g_target_y == 0){
2978         g_target_x = unitBreak->y;
2979         g_target_y = unitBreak->x;
2980     }
2981
2982     possionX = g_target_y;
2983     possionY = g_target_x;
2984
2985     SKILL *S6T = unitBreak->C.S;
2986
2987     while(unitBreak->C.S){
2988         if(unitBreak->C.S->type == 1){
2989             //FieldScene *FS = [[FieldScene alloc] init];//これが原因
2990             int rdmCnt;
2991
2992             rdmCnt = rand()%100;
2993
2994             if(rdmCnt > 20)
2995                 for(int i = 0;unitBreak->C.S->list[i] > 0;i++){
2996                     if(BC[unitBreak->C.S->list[i]-1].type == BC_ANTEI){
2997                         if(MC[chipNum[possionX][possionY]].type == MC_ANTEI && buildNum[possionX][possionY] < 0){
2998
2999                             int rdmCnt2;
3000                             rdmCnt2 = rand()%100;
3001                             if(rdmCnt2 > 40) continue;
3002
3003
3004                             int UT = 0;
3005
3006                             if(unitBreak->team == 0){
3007                                 UT = 0;
3008                             }else if(unitBreak->team == 2){
3009                                 UT = 1;
3010                             }else if(unitBreak->team == 1){
3011                                 UT = 2;
3012                             }
3013
3014                             if(BC[unitBreak->C.S->list[i]-1].Csupply <= P[UT].resource &&
3015                                BC[unitBreak->C.S->list[i]-1].Cfood <= P[UT].food &&
3016                                BC[unitBreak->C.S->list[i]-1].Cmoney <= P[UT].money
3017                                ){
3018                                 if(unitBreak->team == 0){
3019                                     buildTeam[possionX][possionY] = 0;
3020                                 }
3021                                 if(unitBreak->team == 1){
3022                                     buildTeam[possionX][possionY] = 4;
3023                                 }
3024                                 if(unitBreak->team == 2){
3025                                     buildTeam[possionX][possionY] = 2;
3026                                 }
3027                                 buildNum[possionX][possionY] = BC[unitBreak->C.S->list[i]-1].chipNumb;
3028                                 /*
3029                                 P[UT].resource -= BC[unitBreak->C.S->list[i]-1].Csupply;
3030                                 P[UT].food -= BC[unitBreak->C.S->list[i]-1].Cfood;
3031                                 P[UT].money -= BC[unitBreak->C.S->list[i]-1].Cmoney;
3032                                */
3033                                //[FS addBuildStatus];
3034                                 cpuBuildDoneFlag = true;
3035                                  [self addBuildStatusfix];
3036                                 ST6type = i;
3037                                 unitBreak->C.S = S6T;
3038                                 if(g_target_x == unitBreak->y && g_target_y == unitBreak->x){
3039                                     unitNoMoveStanbyFlag = true;
3040                                 }
3041                                 return;
3042                             }
3043                         }
3044                     }
3045                 }
3046
3047             rdmCnt = rand()%100;
3048
3049             if(rdmCnt > 20)
3050                 for(int i = 0;unitBreak->C.S->list[i] > 0;i++){
3051                     if(BC[unitBreak->C.S->list[i]-1].type == BC_CHIKURIN){
3052                         if(MC[chipNum[possionX][possionY]].type == MC_CHIKURIN && buildNum[possionX][possionY] < 0){
3053
3054
3055                             int rdmCnt2;
3056
3057                             rdmCnt2 = rand()%100;
3058                             if(rdmCnt2 > 40) continue;
3059
3060
3061                             int UT = 0;
3062
3063                             if(unitBreak->team == 0){
3064                                 UT = 0;
3065                             }else if(unitBreak->team == 2){
3066                                 UT = 1;
3067                             }else if(unitBreak->team == 1){
3068                                 UT = 2;
3069                             }
3070
3071                             if(BC[unitBreak->C.S->list[i]-1].Csupply <= P[UT].resource &&
3072                                BC[unitBreak->C.S->list[i]-1].Cfood <= P[UT].food &&
3073                                BC[unitBreak->C.S->list[i]-1].Cmoney <= P[UT].money
3074                                ){
3075
3076                                 if(unitBreak->team == 0){
3077                                     buildTeam[possionX][possionY] = 0;
3078                                 }
3079                                 if(unitBreak->team == 1){
3080                                     buildTeam[possionX][possionY] = 4;
3081                                 }
3082                                 if(unitBreak->team == 2){
3083                                     buildTeam[possionX][possionY] = 2;
3084                                 }
3085
3086                                 buildNum[possionX][possionY] = BC[unitBreak->C.S->list[i]-1].chipNumb;
3087                                 buildTeam[possionX][possionY] = unitBreak->team;
3088                                 /*
3089                                 P[UT].resource -= BC[unitBreak->C.S->list[i]-1].Csupply;
3090                                 P[UT].food -= BC[unitBreak->C.S->list[i]-1].Cfood;
3091                                 P[UT].money -= BC[unitBreak->C.S->list[i]-1].Cmoney;
3092                                 */
3093                                 //[FS addBuildStatus];
3094                                 cpuBuildDoneFlag = true;
3095                                  [self addBuildStatusfix];
3096                                 ST6type = i;
3097                                 unitBreak->C.S = S6T;
3098                                 if(g_target_x == unitBreak->y && g_target_y == unitBreak->x){
3099                                     unitNoMoveStanbyFlag = true;
3100                                 }
3101                                 return;
3102                             }
3103                         }
3104
3105                     }
3106                 }
3107
3108             rdmCnt = rand()%100;
3109
3110             if(rdmCnt > 20)
3111                 for(int i = 0;unitBreak->C.S->list[i] > 0;i++){
3112                     if(BC[unitBreak->C.S->list[i]-1].type == BC_ASASE){
3113                         if(MC[chipNum[possionX][possionY]].type == MC_ASASE && buildNum[possionX][possionY] < 0){
3114
3115                             int rdmCnt2;
3116
3117                             rdmCnt2 = rand()%100;
3118                             if(rdmCnt2 > 40) continue;
3119
3120                             int UT = 0;
3121
3122                             if(unitBreak->team == 0){
3123                                 UT = 0;
3124                             }else if(unitBreak->team == 2){
3125                                 UT = 1;
3126                             }else if(unitBreak->team == 1){
3127                                 UT = 2;
3128                             }
3129
3130                             if(BC[unitBreak->C.S->list[i]-1].Csupply <= P[UT].resource &&
3131                                BC[unitBreak->C.S->list[i]-1].Cfood <= P[UT].food &&
3132                                BC[unitBreak->C.S->list[i]-1].Cmoney <= P[UT].money
3133                                ){
3134
3135                                 if(unitBreak->team == 0){
3136                                     buildTeam[possionX][possionY] = 0;
3137                                 }
3138                                 if(unitBreak->team == 1){
3139                                     buildTeam[possionX][possionY] = 4;
3140                                 }
3141                                 if(unitBreak->team == 2){
3142                                     buildTeam[possionX][possionY] = 2;
3143                                 }
3144
3145                                 buildNum[possionX][possionY] = BC[unitBreak->C.S->list[i]-1].chipNumb;
3146                                 buildTeam[possionX][possionY] = unitBreak->team;
3147                                 /*
3148                                 P[UT].resource -= BC[unitBreak->C.S->list[i]-1].Csupply;
3149                                 P[UT].food -= BC[unitBreak->C.S->list[i]-1].Cfood;
3150                                 P[UT].money -= BC[unitBreak->C.S->list[i]-1].Cmoney;
3151                                 */
3152                                 //[FS addBuildStatus];
3153                                 cpuBuildDoneFlag = true;
3154                                  [self addBuildStatusfix];
3155                                 ST6type = i;
3156                                 unitBreak->C.S = S6T;
3157                                 if(g_target_x == unitBreak->y && g_target_y == unitBreak->x){
3158                                     unitNoMoveStanbyFlag = true;
3159                                 }
3160                                 return;
3161                             }
3162                         }
3163                     }
3164                 }
3165         }
3166         unitBreak->C.S = unitBreak->C.S->next;
3167     }
3168     unitBreak->C.S = S6T;
3169
3170     if(g_target_x == unitBreak->y && g_target_y == unitBreak->x){
3171         unitNoMoveStanbyFlag = true;
3172     }
3173 }
3174
3175 -(void)atkSelectionFix{
3176     //おまんちん
3177
3178     if(!Utarget) return;
3179
3180     for(int g = 0;g <= chipWidth;g++){
3181         for(int h = 0; h <= chipHeight;h++){
3182             g_attackRangeBeta [h][g] = 0;
3183         }
3184     }
3185     [self LookupMovableRange:unitBreak->y startY:unitBreak->x aPiece:&unitBreak->C turnSide:YES];
3186
3187
3188     for (int x = 0; x <= chipWidth;x++) {
3189         for(int y = 0; y <= chipHeight;y++){
3190
3191             if(g_selectRange[y][x] > 0 && g_selectRange[y][x] != 999 ){
3192
3193                 ATTACK *UAT;
3194                 UA = unitBreak->C.A;
3195                 UAT = unitBreak->C.A;
3196
3197
3198
3199                 if(!UAT) return;
3200
3201                 static double mostDmg = 0;
3202                 static int mostDmgNum = 0;
3203                 static int mostDmgCnt = 0;
3204                 if(unitBreak->C.A) {
3205
3206                     while (unitBreak->C.A){
3207
3208                         double theDmg = 0;
3209                     double mpCost = floor(unitBreak->C.A->MP + unitBreak->C.A->pMP*unitBreak->C.S_M.MP/100 + 0.5);
3210
3211                     double vigcost = unitBreak->C.A->vigor;
3212
3213                     double urSupposedToGet;
3214
3215                     if(unitBreak->C.A) urSupposedToGet = pow(8, log(3+unitBreak->C.A->totalD/16));
3216
3217                     double asItIs;
3218
3219                     if(Utarget) asItIs = 1/log(3+Utarget->C.S_C.DEF/64);
3220
3221
3222                     double oopsIsRight = 0;
3223
3224                     if(unitBreak->C.A){
3225                         if(unitBreak->C.A->melee){
3226                             oopsIsRight = unitBreak->C.S_C.MEL;
3227                         }else
3228                             oopsIsRight = unitBreak->C.S_C.MIS;
3229                     }
3230                     oopsIsRight = oopsIsRight/100;
3231
3232                     mpCost = unitBreak->C.A->MP + unitBreak->C.A->pMP*unitBreak->C.S_M.MP/100 + 0.5;
3233
3234                     if(!Utarget->C.aura && unitBreak->C.A->D){
3235                         if(unitBreak->C.A->D->type == 0) theDmg = ((unitBreak->C.S_C.ATK*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3236                                                              - Utarget->C.S_C.DEF*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs;
3237                         if(unitBreak->C.A->D->type == 1) theDmg = ((unitBreak->C.S_C.DEF*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3238                                                              - Utarget->C.S_C.ATK*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs;
3239                         if(unitBreak->C.A->D->type == 2) theDmg = ((unitBreak->C.S_C.ACU*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3240                                                              - Utarget->C.S_C.EVA*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs;
3241                         if(unitBreak->C.A->D->type == 3) theDmg = ((unitBreak->C.S_C.EVA*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3242                                                              - Utarget->C.S_C.ACU*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs;
3243                         if(unitBreak->C.A->D->type == 4) theDmg = ((unitBreak->C.S_C.CAP*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3244                                                              - Utarget->C.S_C.CAP*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs;
3245                         if(unitBreak->C.A->D->type == 5) theDmg = unitBreak->C.A->totalD;
3246                     }else if(unitBreak->C.A->D){
3247                         double val = val = 1/log(3+Utarget->C.S_C.MP/64);
3248                         if(unitBreak->C.A->D->type == 0) theDmg = ((unitBreak->C.S_C.ATK*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3249                                                              - Utarget->C.S_C.DEF*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs*val;
3250                         if(unitBreak->C.A->D->type == 1) theDmg = ((unitBreak->C.S_C.DEF*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3251                                                              - Utarget->C.S_C.ATK*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs*val;
3252                         if(unitBreak->C.A->D->type == 2) theDmg = ((unitBreak->C.S_C.ACU*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3253                                                              - Utarget->C.S_C.EVA*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs*val;
3254                         if(unitBreak->C.A->D->type == 3) theDmg = ((unitBreak->C.S_C.EVA*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3255                                                              - Utarget->C.S_C.ACU*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs*val;
3256                         if(unitBreak->C.A->D->type == 4) theDmg = ((unitBreak->C.S_C.CAP*unitBreak->C.S_C.HP/unitBreak->C.S_M.HP+urSupposedToGet*unitBreak->C.S_C.vigor/100)*oopsIsRight
3257                                                              - Utarget->C.S_C.CAP*Utarget->C.S_C.HP/Utarget->C.S_M.HP/2*Utarget->C.S_C.vigor/100)*asItIs*val;
3258                         if(unitBreak->C.A->D->type == 5) theDmg = unitBreak->C.A->totalD*val;
3259                     }
3260                     double val2 = log(3+Utarget->C.S_C.MP/64);
3261                     if(unitBreak->C.aura){
3262                         theDmg = theDmg*val2;
3263                     }
3264                     if(unitBreak->C.A->D){
3265                         if(U->C.A->D->fix == 2){
3266                             theDmg = theDmg/2 + unitBreak->C.S_C.HIT/2;
3267
3268                         }else if(U->C.A->D->fix == 1){
3269                             theDmg = theDmg/2 + (unitBreak->C.S_C.ATK/2 + unitBreak->C.S_C.HIT)/2/2;
3270
3271                         }else if(unitBreak->C.A->D->fix == 0){
3272                             theDmg = theDmg/2 + unitBreak->C.S_C.ATK/2;
3273                         }}
3274
3275                     theDmg = [self dmgResistFix:theDmg];
3276
3277                         NSLog(@"%@:%g", unitBreak->C.A->name, theDmg);
3278                     if(unitBreak->C.A->rangeB >= unitBreak->atkRange && unitBreak->C.A->rangeA <= unitBreak->atkRange && mpCost <= unitBreak->C.S_C.MP && vigcost <= unitBreak->C.S_C.vigor){
3279
3280                         if(mostDmg <= theDmg){
3281                             mostDmg = theDmg;
3282                             mostDmgNum = mostDmgCnt;
3283                             CPUmostDmgChoice = true;
3284                         }
3285
3286                     }mostDmgCnt++;
3287
3288                         unitBreak->C.A = unitBreak->C.A->next;
3289                     }unitBreak->C.A = UAT;
3290
3291                 }unitBreak->C.A = UAT;
3292
3293                 for(int i = 0;i < mostDmgNum;i++){
3294                     unitBreak->C.A = unitBreak->C.A->next;
3295                 }
3296                 UA = unitBreak->C.A;
3297
3298
3299                 if(UA)
3300                     if(UA->rangeB <= 0) {
3301                         UA = unitBreak->C.A;
3302                         UA->rangeB = 1;
3303                         crCAL1 = 0;
3304                     }
3305
3306                 if(UA->extent > 0){
3307                     cpuAtkExtendFlag = true;
3308                 }
3309
3310                 mostDmg = 0;
3311                 mostDmgNum = 0;
3312                 mostDmgCnt = 0;
3313
3314                 unitBreak->C.A = UAT;
3315                 crCAL1 = 0;
3316                 while (unitBreak->C.A && UA != unitBreak->C.A) {
3317                     unitBreak->C.A = unitBreak->C.A->next;
3318                     crCAL1++;
3319                 }
3320                 unitBreak->C.A = UAT;
3321
3322                 crCAL = crCAL1;
3323
3324                 //unitBreak->atkRange = UA->rangeB;
3325                 //NSLog(@"unitBreak->atkRange %d", unitBreak->atkRange);
3326
3327             }
3328         }
3329     }
3330
3331 }
3332
3333 -(double)dmgResistFix:(double)DMG{
3334
3335     if(Utarget->C.A->D){
3336         if(unitBreak->C.A->D->seed == 0) DMG = DMG * Utarget->C.R_C.blow/100;
3337         if(unitBreak->C.A->D->seed == 1) DMG = DMG * Utarget->C.R_C.slash/100;
3338         if(unitBreak->C.A->D->seed == 2) DMG = DMG * Utarget->C.R_C.stub/100;
3339         if(unitBreak->C.A->D->seed == 3) DMG = DMG * Utarget->C.R_C.arrow/100;
3340         if(unitBreak->C.A->D->seed == 4) DMG = DMG * Utarget->C.R_C.gun/100;
3341         if(unitBreak->C.A->D->seed == 5) DMG = DMG * Utarget->C.R_C.shell/100;
3342
3343         if(unitBreak->C.A->D->seed == 6) DMG = DMG * Utarget->C.R_C.flame/100;
3344         if(unitBreak->C.A->D->seed == 7) DMG = DMG * Utarget->C.R_C.cold/100;
3345         if(unitBreak->C.A->D->seed == 8) DMG = DMG * Utarget->C.R_C.electoric/100;
3346         if(unitBreak->C.A->D->seed == 9) DMG = DMG * Utarget->C.R_C.air/100;
3347         if(unitBreak->C.A->D->seed == 10) DMG = DMG * Utarget->C.R_C.water/100;
3348         if(unitBreak->C.A->D->seed == 11) DMG = DMG * Utarget->C.R_C.gas/100;
3349         if(unitBreak->C.A->D->seed == 12) DMG = DMG * Utarget->C.R_C.holy/100;
3350         if(unitBreak->C.A->D->seed == 13) DMG = DMG * Utarget->C.R_C.dark/100;
3351         if(unitBreak->C.A->D->seed == 14) DMG = DMG * Utarget->C.R_C.explosion/100;
3352         if(unitBreak->C.A->D->seed == 15) DMG = DMG * Utarget->C.R_C.blood/100;
3353
3354         if(unitBreak->C.A->D->seed == 16) DMG = DMG * Utarget->C.R_C.paralysis/100;
3355         if(unitBreak->C.A->D->seed == 17) DMG = DMG * Utarget->C.R_C.confusion/100;
3356         if(unitBreak->C.A->D->seed == 18) DMG = DMG * Utarget->C.R_C.poison/100;
3357         if(unitBreak->C.A->D->seed == 19) DMG = DMG * Utarget->C.R_C.sleep/100;
3358         if(unitBreak->C.A->D->seed == 20) DMG = DMG * Utarget->C.R_C.charm/100;
3359         if(unitBreak->C.A->D->seed == 21) DMG = DMG * Utarget->C.R_C.silent/100;
3360     }
3361     return DMG;
3362 }
3363
3364 -(void)healBreak{
3365
3366     for(int g = 0;g <= chipWidth;g++){
3367         for(int h = 0; h <= chipHeight;h++){
3368             g_attackRangeBeta [h][g] = 0;
3369         }
3370     }
3371     [self LookupMovableRange:unitBreak->y startY:unitBreak->x aPiece:&unitBreak->C turnSide:YES];
3372
3373
3374     for (int x = 0; x <= chipWidth;x++) {
3375         for(int y = 0; y <= chipHeight;y++){
3376
3377             if(g_selectRange[y][x] > 0 && g_selectRange[y][x] != 999 ){
3378
3379                 ATTACK *UAT;
3380                 UA = unitBreak->C.A;
3381                 UAT = unitBreak->C.A;
3382
3383
3384
3385                 if(!UAT) return;
3386                 crCAL1 = 0;
3387                 while (unitBreak->C.A) {
3388                     double mpcost = floor(unitBreak->C.A->MP + unitBreak->C.A->pMP*unitBreak->C.S_M.MP/100 + 0.5);
3389
3390                     double vigcost = unitBreak->C.A->vigor;
3391
3392                     if(UA->rangeB <= unitBreak->C.A->rangeB && mpcost <= unitBreak->C.S_C.MP && vigcost <= unitBreak->C.S_C.vigor){
3393
3394                         if(unitBreak->C.A->D){
3395
3396                         if(unitBreak->C.A->D->sort == 1){
3397                             unitBreak->C.A = unitBreak->C.A->next;
3398                             continue;
3399                         }
3400
3401                         }else{
3402                             unitBreak->C.A = unitBreak->C.A->next;
3403                             continue;
3404                         }
3405                         UA = unitBreak->C.A;
3406                     }
3407
3408                     unitBreak->C.A = unitBreak->C.A->next;
3409                 }unitBreak->C.A = UAT;
3410
3411
3412
3413                 if(UA)
3414                     if(UA->rangeB <= 0) {
3415                         UA = unitBreak->C.A;
3416                         UA->rangeB = 1;
3417                         crCAL1 = 0;
3418                     }
3419
3420                 if(UA->extent > 0){
3421                     cpuAtkExtendFlag = true;
3422                 }
3423
3424                 while (unitBreak->C.A && UA != unitBreak->C.A) {
3425                     unitBreak->C.A = unitBreak->C.A->next;
3426                     crCAL1++;
3427                 }unitBreak->C.A = UAT;
3428
3429                 unitBreak->atkRange = UA->rangeB;
3430                 //NSLog(@"unitBreak->atkRange %d", unitBreak->atkRange);
3431                 for(int g = 0;g <= chipWidth;g++){
3432                     for(int h = 0; h <= chipHeight;h++){
3433                         g_attackRangeAlpha [h][g] = 0;
3434                     }
3435                 }
3436
3437                 [self checkAttackRange:x startY:y leftPow:UA->rangeB+1 pieceType:unitBreak->C.S_C.typeMONS aMap:g_attackRangeAlpha aPiece:&unitBreak->C];
3438
3439                 for (int j = 0; j <= chipWidth;j++) {
3440                     for(int k = 0;k <= chipHeight;k++){
3441                         if(g_attackRangeBeta[k][j] < g_attackRangeAlpha[k][j]) g_attackRangeBeta[k][j] = g_attackRangeAlpha[k][j];
3442                     }
3443                 }
3444             }
3445         }
3446     }
3447 }
3448 -(void)addBuildStatusfix{
3449
3450     int omgCnt = 0;
3451     B = BTop;
3452     while (B->next) {omgCnt++;
3453         B = B->next;
3454     }
3455     B->next = calloc(1, sizeof(BUILD));
3456     B = B->next;
3457     B->next = NULL;
3458     if(omgCnt == 0) BTop = B;
3459     B->number = registerNumB;
3460
3461
3462     B->chipNumber = BC[buildNum[possionX][possionY]].chipNumb;
3463     B->x = possionX;
3464     B->y = possionY;
3465     B->C = BC[buildNum[possionX][possionY]];
3466     B->img = [BC[buildNum[possionX][possionY]].img retain];
3467     unitColorInitFlag = true;
3468
3469     if(cpuBuildDoneFlag){
3470         B->C.invisible = true;
3471     }
3472
3473     if(buildTeam[possionX][possionY] == 0 || buildTeam[possionX][possionY] == 1){
3474         B->team = 0;
3475         if(unitTeam[possionX][possionY] == 0){
3476             U->joinArmyFromNext = true;
3477             U->persuasion = true;
3478         }
3479     }
3480     if(buildTeam[possionX][possionY] == 2 || buildTeam[possionX][possionY] == 3){
3481         B->team = 2;
3482     }
3483     if(buildTeam[possionX][possionY] == 4 || buildTeam[possionX][possionY] == 5){
3484         B->team = 1;
3485     }
3486     if(buildTeam[possionX][possionY] == -1){
3487         B->team = -1;
3488
3489     }
3490
3491     registerNumB++;
3492     B = BTop;
3493 }
3494
3495
3496 -(bool)cpuMoveFunc{
3497
3498     static int waitTimer = 50;
3499
3500     if (waitTimer > 0) {
3501         waitTimer--;
3502         return false;
3503     }else{
3504         waitTimer = 50;
3505     }
3506
3507     g_cursol_x = unitBreak->y;
3508     g_cursol_y = unitBreak->x;
3509
3510     if(moveFlag && g_selectRange[possionX][possionY] > 0){
3511
3512         [self searchRoute];
3513
3514         for(int i = 0;i<=chipWidth;i++){
3515             for(int j = 0;j<=chipHeight;j++){
3516                 g_map[j][i] = chipNum[j][i];
3517                 g_selectRange[j][i] = 0;
3518             }
3519         }
3520         moveFlag = false;
3521         stanbyFlag = true;
3522         wtPx = g_target_y;
3523         wtPy = g_target_x;
3524         wtMovedFlag = true;
3525         B = BTop;
3526         while (B) {
3527             if(B->x == wtPx && B->y == wtPy && B->C.capture){
3528                 buildCaptureFlag = true;
3529             }
3530             B = B->next;
3531         }B = BTop;
3532
3533     }
3534
3535
3536     moveFlag = true;
3537     attackFlag = false;
3538     stanbyFlag = true;
3539     menuDisplayFlag = false;
3540     Uselected = unitBreak;
3541     return true;
3542 }
3543
3544 -(void)cpuATKextentFunc{
3545
3546
3547     U = UTop;
3548
3549     if(attackExtentFlag2 && g_attackRangeExtent[Utarget->x][Utarget->y] > 0){
3550         attackExtentFlag2 = false;
3551         attackExtentFlag = false;
3552         attackFlag = false;
3553         cpuAtkExtendFlag3 = true;
3554         for (int i = 0;i < 255;i++) {
3555             DUN[i] = -1;
3556         }
3557
3558         int Unum = 0;
3559
3560
3561         while (U) {
3562             Unum++;
3563             U = U->next;
3564         }U = UTop;
3565
3566         while(U->number != AUN[1]){
3567             U = U->next;
3568         }
3569         UNIT *AUNU = U;
3570
3571         U = UTop;
3572         int z = 0;
3573         static bool okflag = true;
3574         while(U){
3575             for (int i = 0;i < 1002;i++) {
3576                 for (int k = 0;k < 1002;k++) {
3577                     objeR[i][k] = 0;
3578                 }
3579             }
3580             if(U->chipNumberL < 0){
3581                 [self checkAttackRangeExtent:Utarget->y startY:Utarget->x leftPow:AUNU->C.A->extent+1 pieceType:1 aMap:g_attackRangeExtent aPiece:&AUNU->C];
3582             }else {
3583                 [self checkAttackRangeExtent:Utarget->y startY:Utarget->x leftPow:AUNU->C.A->extent+1 pieceType:1 aMap:g_attackRangeExtent aPiece:&AUNU->C];
3584             }
3585
3586             int Cnum = 0;
3587
3588             for(int bx=1;bx<=chipWidth;bx++){
3589                 for(int by=1;by<=chipHeight;by++){
3590                     if(g_attackRangeExtent[bx][by] != 999 && g_attackRangeExtent[bx][by] > 0){
3591
3592                         if(g_attackRangeExtent[U->x][U->y] > 0 && attackExceptNumber != U-> number){
3593                             Cnum++;
3594                             if(Unum < Cnum) goto lolzOMFG;
3595
3596
3597
3598
3599
3600                             if(UP)
3601                             {
3602                                 if(!UPT){
3603                                     UPT = UP;
3604                                 }
3605
3606                                 UP = UPT;
3607                                 while (UP) {
3608                                     if(UP->x == U->x && UP->y == U->y){
3609
3610                                         break;
3611                                     }else{
3612                                         okflag = true;
3613                                     }
3614
3615                                     UP = UP->next;
3616                                 }
3617
3618                             }
3619                             UP = UPT;
3620
3621                             if(!UP) UP = calloc(1, sizeof(UNITPOINT));
3622                             else if(UP){
3623                                 while(UP->next) UP = UP->next;
3624                             }
3625                             if(okflag){
3626                                 z++;
3627                                 UP->x = U->x;
3628                                 UP->y = U->y;
3629                                 UP->next = calloc(1, sizeof(UNITPOINT));
3630                                 okflag = false;
3631                                 DUN[z] = U->number;
3632
3633                             }
3634                         }
3635
3636                     }
3637                 }
3638             }
3639
3640         lolzOMFG:
3641             UP = NULL;
3642             UPT = NULL;
3643
3644             U = U->next;
3645         }U = UTop;
3646         okflag = true;
3647         NSLog(@"%d", DUN[0]);
3648         return;
3649     }else if(attackExtentFlag2){
3650         attackExtentFlag2 = false;
3651         attackExtentFlag = false;
3652         attackFlag = false;
3653         cpuAtkExtendFlag3 = false;
3654     }
3655
3656
3657
3658
3659
3660
3661 }
3662
3663
3664 -(void)checkStep:(int)cnsPow tX:(int)startX tY:(int)startY type:(int)pieceType aMap:(int[][1002])aMap{
3665
3666     int i0;
3667
3668     aMap[startY][startX] = cnsPow;
3669
3670     i0 = cnsPow + g_moveCost[pieceType][g_map[startY-1][startX]];
3671     if(aMap[startY-1][startX] > i0) [self checkStep:i0 tX:startX tY:startY-1 type:pieceType aMap:aMap];
3672
3673     i0 = cnsPow + g_moveCost[pieceType][g_map[startY+1][startX]];
3674     if(aMap[startY+1][startX] > i0) [self checkStep:i0 tX:startX tY:startY+1 type:pieceType aMap:aMap];
3675
3676     i0 = cnsPow + g_moveCost[pieceType][g_map[startY][startX-1]];
3677     if(aMap[startY][startX-1] > i0) [self checkStep:i0 tX:startX-1 tY:startY type:pieceType aMap:aMap];
3678
3679     i0 = cnsPow + g_moveCost[pieceType][g_map[startY][startX+1]];
3680     if(aMap[startY][startX+1] > i0) [self checkStep:i0 tX:startX+1 tY:startY type:pieceType aMap:aMap];
3681
3682
3683 }
3684
3685 -(void)checkEnemyRange:(int)cnsPow cntNum:(int)cntNum tX:(int)startX tY:(int)startY aMap:(int[][1002])aMap{
3686
3687     int i0;
3688
3689     aMap[startY][startX] = cnsPow;
3690     //NSLog(@"[%d,%d]%d\n", startY, startX, cnsPow);
3691     i0 = cnsPow - 1;
3692     if(aMap[startY-1][startX] < i0)
3693         [self checkEnemyRange:i0 cntNum:cnsPow tX:startX tY:startY-1 aMap:aMap];
3694
3695     i0 = cnsPow - 1;
3696     if(aMap[startY+1][startX] < i0)
3697         [self checkEnemyRange:i0 cntNum:cnsPow tX:startX tY:startY+1 aMap:aMap];
3698
3699     i0 = cnsPow - 1;
3700     if(aMap[startY][startX-1] < i0)
3701         [self checkEnemyRange:i0 cntNum:cnsPow tX:startX-1 tY:startY aMap:aMap];
3702
3703     i0 = cnsPow - 1;
3704     if(aMap[startY][startX+1] < i0)
3705         [self checkEnemyRange:i0 cntNum:cnsPow tX:startX+1 tY:startY aMap:aMap];
3706
3707
3708 }
3709
3710
3711 -(void)mouseUp:(NSEvent *)theEvent{
3712
3713 }
3714
3715 -(void)loadMesh:(NSMutableArray *)theMapString index:(int)index{
3716
3717
3718 }
3719
3720
3721 - (void)drawRect:(NSRect)dirtyRect
3722 {
3723
3724     if(cpuModeMOVEflag && !unitMoveEndFlag && !cpuIsAttackingFlag)
3725         for (int x = 1; x <= chipWidth;x++) {
3726             for(int y = 1;y <= chipHeight;y++){
3727
3728                 if(g_selectRange[y][x] > 0 && !cpuOMFGmoveATKfixFlag){
3729                     [self DrawImage:chipMove x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.8];
3730
3731                 }
3732
3733             }
3734         }
3735
3736
3737
3738     int bx, by;
3739     for(bx=1;bx<=chipWidth;bx++){
3740         for(by=1;by<=chipHeight;by++){
3741             //[self DrawImage:chip x:(bx-1)*32-1 y:(by-1)*32 cx:bx cy:by f:1.0];
3742             [self DrawImage:MC[chipNum[bx][by]].img x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:1.0];
3743             if(buildNum[bx][by] >= 0) {
3744
3745
3746                 //[self DrawImage:BC[buildNum[bx][by]].img x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:1.0];
3747
3748                 B = BTop;
3749                 while (B) {
3750                     if(B->x == bx && B->y == by) break;
3751                     B = B->next;
3752                 }
3753                 if(B && !B->C.invisible) [self DrawImage:B->img x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:1.0];
3754                 B = BTop;
3755
3756             }
3757
3758             if(g_selectRange[bx][by] > 0 && moveFlag){
3759                 [self DrawImage:chipMove x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:0.8];
3760                 switch (g_selectRange[bx][by]) {
3761                     case 1:
3762                         [self DrawImage:n1 x:bx*32 y:by*32 cx:bx cy:by f:1];
3763                         break;
3764                     case 2:
3765                         [self DrawImage:n2 x:bx*32 y:by*32 cx:bx cy:by f:1];
3766                         break;
3767                     case 3:
3768                         [self DrawImage:n3 x:bx*32 y:by*32 cx:bx cy:by f:1];
3769                         break;
3770                     case 4:
3771                         [self DrawImage:n4 x:bx*32 y:by*32 cx:bx cy:by f:1];
3772                         break;
3773                     case 5:
3774                         [self DrawImage:n5 x:bx*32 y:by*32 cx:bx cy:by f:1];
3775                         break;
3776                     case 6:
3777                         [self DrawImage:n6 x:bx*32 y:by*32 cx:bx cy:by f:1];
3778                         break;
3779                     case 7:
3780                         [self DrawImage:n7 x:bx*32 y:by*32 cx:bx cy:by f:1];
3781                         break;
3782                     case 8:
3783                         [self DrawImage:n8 x:bx*32 y:by*32 cx:bx cy:by f:1];
3784                         break;
3785                     case 9:
3786                         [self DrawImage:n9 x:bx*32 y:by*32 cx:bx cy:by f:1];
3787                         break;
3788                     case 10:
3789                         [self DrawImage:n10 x:bx*32 y:by*32 cx:bx cy:by f:1];
3790                         break;
3791                     case 11:
3792                         [self DrawImage:n11 x:bx*32 y:by*32 cx:bx cy:by f:1];
3793                         break;
3794                     case 12:
3795                         [self DrawImage:n12 x:bx*32 y:by*32 cx:bx cy:by f:1];
3796                         break;
3797                     case 13:
3798                         [self DrawImage:n13 x:bx*32 y:by*32 cx:bx cy:by f:1];
3799                         break;
3800                     case 14:
3801                         [self DrawImage:n14 x:bx*32 y:by*32 cx:bx cy:by f:1];
3802                         break;
3803                     case 15:
3804                         [self DrawImage:n15 x:bx*32 y:by*32 cx:bx cy:by f:1];
3805                         break;
3806                     case 16:
3807                         [self DrawImage:n16 x:bx*32 y:by*32 cx:bx cy:by f:1];
3808                         break;
3809                     case 17:
3810                         [self DrawImage:n17 x:bx*32 y:by*32 cx:bx cy:by f:1];
3811                         break;
3812                     case 18:
3813                         [self DrawImage:n18 x:bx*32 y:by*32 cx:bx cy:by f:1];
3814                         break;
3815                     case 19:
3816                         [self DrawImage:n19 x:bx*32 y:by*32 cx:bx cy:by f:1];
3817                         break;
3818                     case 20:
3819                         [self DrawImage:n20 x:bx*32 y:by*32 cx:bx cy:by f:1];
3820                         break;
3821
3822                     default:
3823                         break;
3824                 }
3825             }
3826
3827             if(g_attackRange[bx][by] > 0 && attackFlag){
3828                 [self DrawImage:chipAttack x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:0.8];
3829             }
3830
3831             /*
3832              if((g_attackRangeExtent[bx][by] > 0 && attackExtentFlag) ||
3833              (g_attackRangeExtent[bx][by] > 0 && cpuAtkExtendFlag3)){
3834              [self DrawImage:chipAttack x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:0.8];
3835              }*/
3836
3837             if(g_summonRange[bx][by] > 0 && summonFlag){
3838                 [self DrawImage:chipSummon x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:0.8];
3839             }
3840
3841             if(unitNum[bx][by] >= 0 || loadNum[bx][by] >= 0) {
3842                 //[self DrawImage:UC[unitNum[bx][by]].img x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:1.0];
3843
3844
3845                 U = UTop;
3846                 while (U) {
3847                     if(U->x == bx && U->y == by) break;
3848                     U = U->next;
3849                 }
3850                 if(U)
3851                     [self DrawImage:U->img x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:1.0];
3852                 U = UTop;
3853
3854             }
3855         }
3856     }
3857
3858     if((cpuModeATTACKflag && !unitMoveEndFlag && !cpuIsAttackingFlag))
3859         for (int x = 1; x <= chipWidth;x++) {
3860             for(int y = 1;y <= chipHeight;y++){
3861
3862                 if(g_attackRangeBeta[y][x] > 0 && !cpuOMFGmoveATKfixFlag){
3863                     [self DrawImage:chipSelect x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3864                     /*
3865                     switch(g_attackRangeBeta[y][x]){
3866                         case 1:
3867                            [self DrawImage:n1 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3868                             break;
3869                         case 2:
3870                             [self DrawImage:n2 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3871                             break;
3872                         case 3:
3873                             [self DrawImage:n3 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3874                             break;
3875                         case 4:
3876                             [self DrawImage:n4 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3877                             break;
3878                         case 5:
3879                             [self DrawImage:n5 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3880                             break;
3881                         case 6:
3882                             [self DrawImage:n6 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3883                             break;
3884                         case 7:
3885                             [self DrawImage:n7 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3886                             break;
3887                         case 8:
3888                             [self DrawImage:n8 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3889                             break;
3890                         case 9:
3891                             [self DrawImage:n9 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3892                             break;
3893                         case 10:
3894                             [self DrawImage:n10 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3895                             break;
3896
3897
3898
3899                     }*/
3900
3901                 }
3902
3903             }
3904         }
3905     /*
3906     if((cpuModeATTACKflag && !unitMoveEndFlag && !cpuIsAttackingFlag && Utarget))
3907         for (int x = 1; x <= chipWidth;x++) {
3908             for(int y = 1;y <= chipHeight;y++){
3909
3910
3911                 for (int x = 0; x <= chipWidth; x++) {
3912                     for (int y = 0; y <= chipHeight; y++) {
3913                         g_attackRangeTheta[y][x] = 0;
3914                     }
3915                 }
3916                 [self checkRangeAttack:Utarget->y startY:Utarget->x leftPow:unitBreak->atkRange+1 pieceType:U->C.S_C.typeMONS aMap:g_attackRangeTheta aPiece:&U->C i:unitBreak->atkRange+1 ];
3917
3918                 for (int i = 0;i < chipWidth;i++) {
3919                     for(int k = 0;k < chipHeight;k++){
3920                         if(g_attackRangeTheta[i][k] > 0)
3921                         g_attackRangeTheta[i][k] =  unitBreak->atkRange+1 - g_attackRangeTheta[i][k];
3922                     }
3923                 }
3924
3925                 if(g_attackRangeTheta[y][x] > 0 && !cpuOMFGmoveATKfixFlag){
3926                     [self DrawImage:chipSelect x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3927
3928                      switch(g_attackRangeTheta[y][x]){
3929                      case 1:
3930                      [self DrawImage:n1 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3931                      break;
3932                      case 2:
3933                      [self DrawImage:n2 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3934                      break;
3935                      case 3:
3936                      [self DrawImage:n3 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3937                      break;
3938                      case 4:
3939                      [self DrawImage:n4 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3940                      break;
3941                      case 5:
3942                      [self DrawImage:n5 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3943                      break;
3944                      case 6:
3945                      [self DrawImage:n6 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3946                      break;
3947                      case 7:
3948                      [self DrawImage:n7 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3949                      break;
3950                      case 8:
3951                      [self DrawImage:n8 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3952                      break;
3953                      case 9:
3954                      [self DrawImage:n9 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3955                      break;
3956                      case 10:
3957                      [self DrawImage:n10 x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3958                      break;
3959
3960
3961
3962                      }
3963
3964                 }
3965
3966             }
3967         }
3968     */
3969
3970     if(cpuIsAttackingFlag || (UA && unitMoveEndFlag)){
3971         for (int x = 1; x <= chipWidth;x++) {
3972             for(int y = 1;y <= chipHeight;y++){
3973                 if(g_attackRangeExtent[y][x] > 0)
3974                     [self DrawImage:chipAttack x:(y-1)*32 y:(x-1)*32 cx:0 cy:0 f:0.6];
3975             }
3976
3977
3978         }
3979     }
3980
3981     /*
3982      if(cpuModeATTACKflag)
3983      for (int x = 0; x <= chipWidth;x++) {
3984      for(int y = 0 ;y <= chipHeight;y++){
3985      if(g_targUnit[y][x] > 0)
3986      [self DrawImage:chipAttack x:(y-1)*32 y:(x-1)*32 cx:bx cy:by f:1.0];
3987      }
3988      }
3989      */
3990     /*
3991      if(cpuModeATTACKflag)
3992      for (int x = 0; x <= chipWidth;x++) {
3993      for(int y = 0 ;y <= chipHeight;y++){
3994      if(g_visibleRange[y][x] > 0)
3995      [self DrawImage:chipMove x:(y-1)*32 y:(x-1)*32 cx:bx cy:by f:1.0];
3996
3997
3998      }
3999      }*/
4000     /*
4001     for (int x = 0; x <= chipWidth;x++) {
4002         for(int y = 0 ;y <= chipHeight;y++){
4003             if(g_attackRangeBeta[y][x] > 0)
4004             [self DrawImage:chipAttack x:(y-1)*32 y:(x-1)*32 cx:bx cy:by f:1.0];
4005         }
4006     }*/
4007
4008     //[self DrawImage:UCselected.img x:currentPosX-32 y:currentPosY-32 cx:0 cy:0 f:1.0];
4009     if(Uselected && unitMoveBugFixFlag)
4010         [self DrawImage:Uselected->img x:currentPosX-32 y:currentPosY-32 cx:0 cy:0 f:1.0];
4011
4012
4013     [self DrawImage:chipSelect x:(possionX-1)*32 y:(possionY-1)*32 cx:0 cy:0 f:1.0];
4014
4015
4016     //if(cpuCursolMode) [self DrawImage:chipSelect x:(g_target_y-1)*32 y:(g_target_x-1)*32 cx:0 cy:0 f:1.0];
4017
4018     if(chipTargetFlag) [self DrawImage:chipTarget x:(wtPx-1)*32 y:(wtPy-1)*32 cx:0 cy:0 f:1.0];
4019
4020     if(Utarget && (cpuIsAttackingFlag || (UA && unitMoveEndFlag)))
4021         [self DrawImage:chipUtarg x:(Utarget->x-1)*32 y:(Utarget->y-1)*32 cx:bx cy:by f:1.0];
4022     //[self DrawImage:chipSelect x:(2-1)*32 y:(1-1)*32 cx:0 cy:0 f:1.0];
4023
4024     /*
4025      for(bx=1;bx<=chipWidth;bx++){
4026      for(by=1;by<=chipHeight;by++){
4027
4028      if(waypR[bx][by] != 999 && waypR[bx][by] > 0){
4029      [self DrawImage:chip x:(bx-1)*32 y:(by-1)*32 cx:bx cy:by f:0.7];
4030
4031      }
4032      }
4033
4034      }*/
4035
4036
4037
4038     if(FieldSceneInitFlag){
4039         initMapFlag = true;
4040         FieldSceneInitFlag = false;
4041     }
4042
4043 }
4044
4045 @end