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